Remove gen-ast-types: the typed-CST generator had no load-bearing consumer

`gen-ast-types.ts` emitted `<grammar>.cst-types.ts` (discriminated-union typing of
the CST). Those artifacts are gitignored build outputs, and nothing depended on
them: the only consumer was a non-gated smoke test, and gen-cst-match's `importFrom`
parameter (the cst-types path) was never used in its body — so the gated cst-match
subsystem is fully independent of cst-types.

Removed the generator and its smoke test, dropped the cst-types emit + the dead
`importFrom` parameter from the gen pipeline, and cleaned the references
(.gitignore/.gitattributes/CI comment/README diagram/emit-corpus filter).

Verified: `npm run gen` emits no cst-types and the committed artifacts stay in
sync; src type-checks; cst-match-totality 31356/0 and the full suite 42/42.

Author: johnsoncodehk

.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

@@ -375,8 +375,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) {

src/gen-ast-types.ts

@@ -1,5 +1,4 @@
-// Generate per-rule, per-ARM destructurers for a grammar's CST — the VALUE-level
-// sibling of gen-ast-types.ts. For every rule it emits
+// Generate per-rule, per-ARM destructurers for a grammar's CST. For every rule it emits
 //
 //   export type <Rule>Match = { arm: 'if', expr: NodeEntry<'Expr'>, … } | …
 //   export function match<Rule>(t: TreeAccess, n: NodeEntry<'Rule'>, src: string): <Rule>Match
@@ -74,7 +73,7 @@ function sanitizeIdent(s: string): string {
 
 const J = (v: unknown) => JSON.stringify(v);
 
-export function generateCstMatch(grammar: CstGrammar, importFrom: string): string {
+export function generateCstMatch(grammar: CstGrammar): string {
   // Same [Await]/[Yield] fork the parsers apply, so the rule-id space (ruleIdOf)
   // agrees with the tree. Matchers/types are emitted for BASE rules only (a fork
   // collapses to its base via RULE_CANON); no-op without ctx markers.