Issue #6: target-agnostic emitter — emitParser/emitLexer for JS/TS/Go/Rust

.gitattributes

@@ -1,8 +1,8 @@
 # Generated artifacts (npm run gen) — committed for consumers, CI-gated for
 # staleness, collapsed in GitHub diffs. The grammar sources (*.ts at the repo
 # root) are the hand-written truth; everything below is derived from them.
-# (*.cst-types.ts / *.cst-match.ts are generated too but NOT committed — see
-# .gitignore; they regenerate locally and in CI before typecheck/gates.)
+# (*.cst-match.ts is generated too but NOT committed — see .gitignore;
+# it regenerates locally and in CI before typecheck/gates.)
 *.tmLanguage.json linguist-generated=true
 *.language-configuration.json linguist-generated=true
 *.monarch.json linguist-generated=true

.github/workflows/ci.yml

@@ -29,9 +29,9 @@ jobs:
 
       - run: npm ci
 
-      # Regenerate every grammar's artifacts FIRST: the uncommitted ones
-      # (*.cst-types.ts / *.cst-match.ts, gitignored) must exist before Typecheck
-      # and the gates, which import them. Then fail if any COMMITTED artifact
+      # Regenerate every grammar's artifacts FIRST: the uncommitted one
+      # (*.cst-match.ts, gitignored) must exist before Typecheck
+      # and the gates, which import it. Then fail if any COMMITTED artifact
       # drifts from the regenerated output (someone edited a grammar but forgot
       # to regenerate). Covers all grammars (sources at the repo root) + the
       # tree-sitter packages.

.gitignore

@@ -18,7 +18,6 @@ tree-sitter/*/src/node-types.json
 tree-sitter/*/src/tree_sitter/
 tree-sitter/*/*.wasm
 
-# Generated CST consumer artifacts (npm run gen) — derived from the grammar, not
+# Generated CST consumer artifact (npm run gen) — derived from the grammar, not
 # committed: generate locally / in CI before typecheck and gates.
-*.cst-types.ts
 *.cst-match.ts

README.md

@@ -338,6 +338,19 @@ const Regex = token(seq(
 
 [`test/agnostic.ts`](test/agnostic.ts) proves it directly — the same engine parses a toy grammar whose identifier token is `Word`, with no templates or regex. The deeper proof is [`html.ts`](html.ts): markup shares *nothing* with TypeScript's token stream, yet the same engine handles it.
 
+### The emitted parser need not be JS — Go, Rust, native
+
+The grammar also derives a **standalone parser in another language**. [`emitParser(grammar, target)`](src/emit.ts) runs one analysis into one language-agnostic IR, and each `Target` renders it — including its own regex-free lexer (`emitParser` reuses `emitLexer(grammar, target)`), so the output has no dependency on the JS runtime and compiles offline:
+
+```ts
+import { emitParser, goTarget, rustTarget } from './src/emit.ts';
+
+writeFileSync('parser.go', emitParser(grammar, goTarget));   // `go build`, no deps
+writeFileSync('parser.rs', emitParser(grammar, rustTarget)); // `rustc`, no crates
+```
+
+The proof is the full languages: the real [`javascript.ts`](javascript.ts) and [`typescript.ts`](typescript.ts) grammars — including the `[Await]/[Yield]` fork, left recursion, the regex/division and template state machines, arrow functions, and the TS type grammar — emit to **TypeScript, Go, and Rust**, and every CST is byte-identical to the reference interpreter. [`test/portable-targets.ts`](test/portable-targets.ts) compiles and runs all three for sixteen grammars (the two real languages plus focused fixtures) on every CI run. The Rust output reaches [oxc](https://github.com/oxc-project/oxc) throughput and the Go output beats [tsgo](https://github.com/microsoft/typescript-go) on the same corpus (an arena keeps both near zero-allocation). Byte-based Go/Rust use UTF-8 offsets — identical to the JS interpreter's for ASCII; non-ASCII offset units differ inherently.
+
 ## Adding a language
 
 A new language is **one grammar file** on the unchanged engine:
@@ -375,8 +388,7 @@ typescript.ts                one grammar (TypeScript combinator API)
         ├─ src/gen-tm.ts ───────────▶ typescript.tmLanguage.json            (TextMate highlighter)
         ├─ src/gen-vscode-config.ts ▶ typescript.language-configuration.json (editor behavior)
         ├─ src/gen-treesitter.ts ───▶ tree-sitter/  (grammar.js + highlights.scm + scanner.c)
-        ├─ src/gen-monarch.ts ──────▶ typescript.monarch.json
-        └─ src/gen-ast-types.ts ────▶ typescript.cst-types.ts
+        └─ src/gen-monarch.ts ──────▶ typescript.monarch.json
 
 shared  src/grammar-utils.ts          structural helpers used across stages
         src/api.ts, types.ts          the grammar's combinator + type surface

src/cli.ts

@@ -4,7 +4,6 @@ import { generateTmLanguage, generateMarkupInjection, generateAliasGrammar, gene
 import { generateLanguageConfig } from './gen-vscode-config.ts';
 import { generateTreeSitter } from './gen-treesitter.ts';
 import { generateMonarch } from './gen-monarch.ts';
-import { generateAstTypes } from './gen-ast-types.ts';
 import { generateCstMatch } from './gen-cst-match.ts';
 import type { CstGrammar, RuleExpr } from './types.ts';
 import { tokenPatternSource } from './token-pattern.ts';
@@ -115,11 +114,8 @@ emit(`tree-sitter/${langName}/package.json`,
 // Monaco Monarch tokenizer (markup-aware: emits a tag/text/raw-text state machine).
 emit(`${langName}.monarch.json`, JSON.stringify(generateMonarch(grammar), null, 2));
 
-// CST node types (TypeScript) — generic over rules, fine for markup too.
-emit(`${langName}.cst-types.ts`, generateAstTypes(grammar));
-
-// Per-arm CST destructurers (value-level sibling of the types above).
-emit(`${langName}.cst-match.ts`, generateCstMatch(grammar, `./${langName}.cst-types.ts`));
+// Per-arm CST destructurers.
+emit(`${langName}.cst-match.ts`, generateCstMatch(grammar));
 
 function formatExpr(expr: RuleExpr): string {
   switch (expr.type) {