diff --git a/src/token-dfa.ts b/src/token-dfa.ts
deleted file mode 100644
index 9584a3b..0000000
--- a/src/token-dfa.ts
+++ /dev/null
@@ -1,347 +0,0 @@
-// ─────────────────────────────────────────────────────────────────────────────
-//  token-dfa.ts — derive a char-code DFA matcher from a token's structured pattern IR
-//  (src/token-pattern.ts): a scanner that dispatches on char codes instead of executing a
-//  regex per token (issue #5). KEPT as the measurement behind that issue — `compileTokenDfa`
-//  is exercised only by test/token-dfa-verify.ts, which found a GENERIC DFA interpreter to be
-//  net-negative vs V8's JIT-compiled sticky regex on all 12 TS tokens (Ident 0.30×). The
-//  emitter that would have turned the DFA into specialized straight-line JS was never wired in
-//  (zero callers) and is removed; revisit from this measurement if char-code scanning is
-//  pursued again.
-//
-//  The lexer matches one token at a time, anchored at `pos`, taking that token's
-//  greedy/longest match (sticky `re.lastIndex = pos; re.exec(s)`). This compiles the
-//  REGULAR subset of the IR — literal · charClass · anyChar · seq · alt · greedy
-//  repeat · never, plus a single TRAILING lookahead over a char class (the `(?!…)`
-//  guard the numeric tokens end with) — to an NFA (Thompson), then a DFA (subset
-//  construction), and runs it over `charCodeAt` code units. `match(s, pos)` returns
-//  the same match length the token's sticky regex would, or -1.
-//
-//  Anything outside that subset (mid-pattern look-around, lookbehind, anchors, a
-//  non-greedy quantifier) → `compileTokenDfa` returns null and the caller keeps using
-//  the regex. So the scanner is byte-identical by construction: a DFA where the IR is
-//  regular, the proven regex elsewhere. Char classes are matched over UTF-16 code
-//  units (0..0xFFFF) exactly like the non-`/u` regexes the lexer emits today.
-// ─────────────────────────────────────────────────────────────────────────────
-
-import type { TokenPattern, TokenCharClassItem } from './types.ts';
-
-// UTF-16 code-unit alphabet. Negated classes complement within [0, MAX_CODE].
-const MAX_CODE = 0xffff;
-
-// A half-open is avoided: ranges are inclusive [lo, hi] of code units.
-export interface Range { lo: number; hi: number }
-
-// ── Char-class → sorted, merged, inclusive ranges ──
-function classRanges(items: TokenCharClassItem[], negate: boolean): Range[] {
-  const raw: Range[] = [];
-  for (const item of items) {
-    if (item.type === 'char') {
-      const c = item.value.charCodeAt(0);
-      raw.push({ lo: c, hi: c });
-    } else {
-      const a = item.from.charCodeAt(0), b = item.to.charCodeAt(0);
-      raw.push({ lo: Math.min(a, b), hi: Math.max(a, b) });
-    }
-  }
-  const merged = mergeRanges(raw);
-  return negate ? complementRanges(merged) : merged;
-}
-
-function mergeRanges(ranges: Range[]): Range[] {
-  if (ranges.length === 0) return [];
-  const sorted = [...ranges].sort((a, b) => a.lo - b.lo || a.hi - b.hi);
-  const out: Range[] = [{ ...sorted[0] }];
-  for (let i = 1; i < sorted.length; i++) {
-    const last = out[out.length - 1], r = sorted[i];
-    if (r.lo <= last.hi + 1) last.hi = Math.max(last.hi, r.hi);
-    else out.push({ ...r });
-  }
-  return out;
-}
-
-function complementRanges(ranges: Range[]): Range[] {
-  // ranges are sorted+merged; complement within [0, MAX_CODE].
-  const out: Range[] = [];
-  let next = 0;
-  for (const r of ranges) {
-    if (r.lo > next) out.push({ lo: next, hi: r.lo - 1 });
-    next = r.hi + 1;
-  }
-  if (next <= MAX_CODE) out.push({ lo: next, hi: MAX_CODE });
-  return out;
-}
-
-// ── NFA (Thompson) ──
-// A transition is either an epsilon move or a move on any code unit inside `ranges`.
-interface NfaState { eps: number[]; trans: { ranges: Range[]; to: number }[] }
-
-class UnsupportedPattern extends Error {}
-
-class Nfa {
-  states: NfaState[] = [];
-  newState(): number { this.states.push({ eps: [], trans: [] }); return this.states.length - 1; }
-  eps(a: number, b: number): void { this.states[a].eps.push(b); }
-  move(a: number, ranges: Range[], b: number): void { this.states[a].trans.push({ ranges, to: b }); }
-}
-
-// Build an NFA fragment for `pattern`; returns [start, accept]. Throws UnsupportedPattern
-// for any non-regular construct so the caller can fall back to the regex.
-function build(nfa: Nfa, pattern: TokenPattern): [number, number] {
-  if (typeof pattern === 'string') return buildLiteral(nfa, pattern);
-  switch (pattern.type) {
-    case 'anyChar': {
-      const s = nfa.newState(), a = nfa.newState();
-      nfa.move(s, [{ lo: 0, hi: MAX_CODE }], a);
-      return [s, a];
-    }
-    case 'charClass': {
-      const ranges = classRanges(pattern.items, pattern.negate);
-      const s = nfa.newState(), a = nfa.newState();
-      if (ranges.length) nfa.move(s, ranges, a);   // empty class → no edge → never matches
-      return [s, a];
-    }
-    case 'seq': {
-      if (pattern.items.length === 0) { const s = nfa.newState(); return [s, s]; }
-      let [start, acc] = build(nfa, pattern.items[0]);
-      for (let i = 1; i < pattern.items.length; i++) {
-        const [s2, a2] = build(nfa, pattern.items[i]);
-        nfa.eps(acc, s2);
-        acc = a2;
-      }
-      return [start, acc];
-    }
-    case 'alt': {
-      const s = nfa.newState(), a = nfa.newState();
-      for (const item of pattern.items) {
-        const [s2, a2] = build(nfa, item);
-        nfa.eps(s, s2);
-        nfa.eps(a2, a);
-      }
-      return [s, a];
-    }
-    case 'repeat': {
-      if (!pattern.greedy) throw new UnsupportedPattern('non-greedy repeat');
-      // min mandatory copies, then either an unbounded star or (max-min) optional copies.
-      const s = nfa.newState();
-      let acc = s;
-      for (let i = 0; i < pattern.min; i++) {
-        const [s2, a2] = build(nfa, pattern.body);
-        nfa.eps(acc, s2);
-        acc = a2;
-      }
-      if (pattern.max === undefined) {
-        // star: acc --eps--> bodyStart, bodyAccept --eps--> acc (loop) and onward.
-        const [s2, a2] = build(nfa, pattern.body);
-        const a = nfa.newState();
-        nfa.eps(acc, s2);
-        nfa.eps(a2, s2);   // loop
-        nfa.eps(acc, a);   // skip (zero more)
-        nfa.eps(a2, a);    // exit after >=1
-        return [s, a];
-      } else {
-        const a = nfa.newState();
-        let cur = acc;
-        for (let i = pattern.min; i < pattern.max; i++) {
-          const [s2, a2] = build(nfa, pattern.body);
-          nfa.eps(cur, s2);
-          nfa.eps(cur, a);   // optional: skip the rest
-          cur = a2;
-        }
-        nfa.eps(cur, a);
-        return [s, a];
-      }
-    }
-    case 'never': {
-      const s = nfa.newState(), a = nfa.newState();   // no edge s→a → never accepts
-      return [s, a];
-    }
-    // Non-regular: the caller must fall back to the regex.
-    case 'lookahead':
-    case 'lookbehind':
-    case 'anchor':
-      throw new UnsupportedPattern(pattern.type);
-  }
-}
-
-function buildLiteral(nfa: Nfa, literal: string): [number, number] {
-  const start = nfa.newState();
-  let cur = start;
-  for (let i = 0; i < literal.length; i++) {
-    const c = literal.charCodeAt(i);
-    const next = nfa.newState();
-    nfa.move(cur, [{ lo: c, hi: c }], next);
-    cur = next;
-  }
-  return [start, cur];
-}
-
-// ── Subset construction → DFA ──
-interface DfaState { accept: boolean; edges: { ranges: Range[]; to: number }[] }
-
-function epsilonClosure(nfa: Nfa, set: Set<number>): Set<number> {
-  const stack = [...set], out = new Set(set);
-  while (stack.length) {
-    const s = stack.pop()!;
-    for (const t of nfa.states[s].eps) if (!out.has(t)) { out.add(t); stack.push(t); }
-  }
-  return out;
-}
-
-function setKey(set: Set<number>): string {
-  return [...set].sort((a, b) => a - b).join(',');
-}
-
-// Partition boundaries: every code unit where some transition's membership flips. We
-// build a sorted list of "cut points" so the alphabet splits into intervals on which
-// every NFA transition is constant — the classic DFA alphabet partition.
-function buildDfa(nfa: Nfa, start: number, accept: number): DfaState[] {
-  const startSet = epsilonClosure(nfa, new Set([start]));
-  const dfa: DfaState[] = [];
-  const index = new Map<string, number>();
-  const queue: Set<number>[] = [];
-
-  const intern = (set: Set<number>): number => {
-    const key = setKey(set);
-    let id = index.get(key);
-    if (id === undefined) {
-      id = dfa.length;
-      index.set(key, id);
-      dfa.push({ accept: set.has(accept), edges: [] });
-      queue.push(set);
-    }
-    return id;
-  };
-
-  intern(startSet);
-  while (queue.length) {
-    const set = queue.shift()!;
-    const id = index.get(setKey(set))!;
-    // Collect this state's outgoing transitions, then split into disjoint intervals.
-    const trans: { ranges: Range[]; to: number }[] = [];
-    for (const ns of set) for (const tr of nfa.states[ns].trans) trans.push(tr);
-    if (trans.length === 0) continue;
-    // Cut points: for every range [lo,hi] add boundaries at lo and hi+1.
-    const cuts = new Set<number>();
-    for (const tr of trans) for (const r of tr.ranges) { cuts.add(r.lo); cuts.add(r.hi + 1); }
-    const points = [...cuts].sort((a, b) => a - b);
-    // For each elementary interval [points[i], points[i+1]-1], gather NFA targets.
-    const edges: { ranges: Range[]; to: number }[] = [];
-    for (let i = 0; i < points.length - 1; i++) {
-      const lo = points[i], hi = points[i + 1] - 1;
-      if (hi < lo) continue;
-      const targets = new Set<number>();
-      for (const tr of trans) {
-        for (const r of tr.ranges) if (r.lo <= lo && hi <= r.hi) { targets.add(tr.to); break; }
-      }
-      if (targets.size === 0) continue;
-      const toId = intern(epsilonClosure(nfa, targets));
-      edges.push({ ranges: [{ lo, hi }], to: toId });
-    }
-    // Merge adjacent intervals that go to the same DFA state (compacts the table).
-    edges.sort((a, b) => a.ranges[0].lo - b.ranges[0].lo);
-    const merged: { ranges: Range[]; to: number }[] = [];
-    for (const e of edges) {
-      const last = merged[merged.length - 1];
-      if (last && last.to === e.to && last.ranges[last.ranges.length - 1].hi + 1 === e.ranges[0].lo) {
-        last.ranges[last.ranges.length - 1].hi = e.ranges[0].hi;
-      } else merged.push({ ranges: [{ ...e.ranges[0] }], to: e.to });
-    }
-    dfa[id].edges = merged;
-  }
-  return dfa;
-}
-
-function dfaNext(state: DfaState, code: number): number {
-  for (const e of state.edges) {
-    for (const r of e.ranges) {
-      if (code < r.lo) break;       // ranges are sorted ascending
-      if (code <= r.hi) return e.to;
-    }
-  }
-  return -1;
-}
-
-// Run the DFA from `pos`, recording every accepting length. Returns the lengths in
-// DESCENDING order (longest first) — what a greedy regex would prefer, and what the
-// trailing-lookahead retry needs.
-function runAcceptLengths(dfa: DfaState[], s: string, pos: number): number[] {
-  const accepts: number[] = [];
-  let state = 0, i = pos;
-  if (dfa[0].accept) accepts.push(0);
-  while (state >= 0 && i < s.length) {
-    const next = dfaNext(dfa[state], s.charCodeAt(i));
-    if (next < 0) break;
-    state = next;
-    i++;
-    if (dfa[state].accept) accepts.push(i - pos);
-  }
-  return accepts.reverse();
-}
-
-// ── Public compile ──
-export interface TokenDfa {
-  /** Match length at `pos`, or -1 — byte-identical to the token's sticky regex exec. */
-  match(s: string, pos: number): number;
-}
-
-// `DfaState` / `buildDfa` are consumed by `compileTokenDfa` below (the measured interpreter).
-
-// A trailing `(?!class)` / `(?=class)` over a single char class is the only look-around
-// the numeric tokens use; supported by retrying shorter body matches until the assertion
-// at the body's end holds. Detected structurally on the IR.
-function trailingLookahead(pattern: TokenPattern): { body: TokenPattern; ranges: Range[]; negate: boolean } | null {
-  if (typeof pattern === 'string' || pattern.type !== 'seq') return null;
-  const last = pattern.items[pattern.items.length - 1];
-  if (typeof last === 'string' || last.type !== 'lookahead') return null;
-  const inner = last.body;
-  if (typeof inner === 'string' || inner.type !== 'charClass') return null;   // only a char-class assertion
-  const body: TokenPattern = pattern.items.length === 2
-    ? pattern.items[0]
-    : { type: 'seq', items: pattern.items.slice(0, -1) };
-  return { body, ranges: classRanges(inner.items, inner.negate), negate: last.negate };
-}
-
-function inRanges(ranges: Range[], code: number): boolean {
-  for (const r of ranges) if (code >= r.lo && code <= r.hi) return true;
-  return false;
-}
-
-/**
- * Compile a token's pattern to a char-code DFA matcher, or return null if the pattern
- * uses a construct outside the supported regular subset (caller falls back to regex).
- */
-export function compileTokenDfa(pattern: TokenPattern): TokenDfa | null {
-  try {
-    const look = trailingLookahead(pattern);
-    if (look) {
-      const nfa = new Nfa();
-      const [start, accept] = build(nfa, look.body);
-      const dfa = buildDfa(nfa, start, accept);
-      const { ranges, negate } = look;
-      return {
-        match(s, pos) {
-          const lens = runAcceptLengths(dfa, s, pos);   // longest first
-          for (const len of lens) {
-            const at = pos + len;
-            const has = at < s.length && inRanges(ranges, s.charCodeAt(at));
-            // negative lookahead succeeds when the char is absent (incl. EOF); positive needs it present.
-            if (negate ? !has : has) return len;
-          }
-          return -1;
-        },
-      };
-    }
-    const nfa = new Nfa();
-    const [start, accept] = build(nfa, pattern);
-    const dfa = buildDfa(nfa, start, accept);
-    return {
-      match(s, pos) {
-        const lens = runAcceptLengths(dfa, s, pos);
-        return lens.length ? lens[0] : -1;
-      },
-    };
-  } catch (e) {
-    if (e instanceof UnsupportedPattern) return null;
-    throw e;
-  }
-}
diff --git a/src/trace-markers.ts b/src/trace-markers.ts
deleted file mode 100644
index 5870bcb..0000000
--- a/src/trace-markers.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-// Region markers for the execution tracer (test/exec-trace.ts).
-//
-// In production these are near-free no-ops: they flip a global flag nothing reads, so
-// leaving `startTrace()`/`endTrace()` around a region you're optimizing costs nothing.
-// The tracer runs an *instrumented* build of the source whose recorded ops are gated on
-// that same flag — so the markers bound exactly the executed region that gets printed.
-export function startTrace(): void { (globalThis as { __REC?: boolean }).__REC = true; }
-export function endTrace(): void { (globalThis as { __REC?: boolean }).__REC = false; }
diff --git a/test/ab-emitted.mjs b/test/ab-emitted.mjs
deleted file mode 100644
index bfa89d1..0000000
--- a/test/ab-emitted.mjs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Interleaved A/B of two EMITTED parser builds on the PR#4 bench files — the standard
-// keep/revert gate for emit-layer perf work (best-of-7 × N=20, min taken, engines
-// alternated within one process so machine drift cancels).
-//   node test/ab-emitted.mjs /tmp/emitted-A.mjs /tmp/emitted-B.mjs
-// Emit a build of the current working tree with:
-//   node -e "const{emitParser}=await import('./src/emit-parser.ts');const g=(await import('./typescript.ts')).default;require('fs').writeFileSync(process.argv[1],emitParser(g))" --input-type=module /tmp/emitted-X.mjs
-// (or see test/emit-parser-bench.ts). For a committed baseline: git stash → emit → stash pop.
-import { readFileSync } from 'node:fs';
-const [pa, pb] = [process.argv[2], process.argv[3]];
-if (!pa || !pb) { console.error('usage: node test/ab-emitted.mjs <A.mjs> <B.mjs>'); process.exit(1); }
-const A = await import(pa);
-const B = await import(pb);
-const paths = [
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts',
-  '/tmp/ts-repo/tests/cases/conformance/fixSignatureCaching.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/parserRealSource7.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserindenter.ts',
-];
-const files = paths.map(p => ({ name: p.split('/').pop(), code: readFileSync(p, 'utf8') }));
-const time = (fn, code, n) => { const s = process.hrtime.bigint(); for (let i = 0; i < n; i++) { try { fn(code); } catch {} } return Number(process.hrtime.bigint() - s) / 1e6 / n; };
-for (const { code } of files) for (let i = 0; i < 10; i++) { try { A.parse(code); B.parse(code); } catch {} }
-let ta = 0, tb = 0;
-for (const { name, code } of files) {
-  let a = Infinity, b = Infinity;
-  for (let r = 0; r < 7; r++) { a = Math.min(a, time(A.parse, code, 20)); b = Math.min(b, time(B.parse, code, 20)); }
-  ta += a; tb += b;
-  console.log(`${name.padEnd(28)} ${a.toFixed(2).padStart(6)} → ${b.toFixed(2).padEnd(6)} ${((a / b - 1) * 100).toFixed(1).padStart(6)}%`);
-}
-console.log(`${'AGGREGATE'.padEnd(28)} ${ta.toFixed(2).padStart(6)} → ${tb.toFixed(2).padEnd(6)} ${((ta / tb - 1) * 100).toFixed(1).padStart(6)}%`);
diff --git a/test/check.ts b/test/check.ts
index a862de7..b484ce5 100644
--- a/test/check.ts
+++ b/test/check.ts
@@ -16,8 +16,10 @@ import { cpus } from 'node:os';
 
 interface Gate { group: string; name: string; args: string[] }
 const GATES: Gate[] = [
-  { group: 'core', name: 'sanity', args: ['test/sanity-check.ts'] },
   { group: 'core', name: 'agnostic', args: ['test/agnostic.ts'] },
+  { group: 'core', name: 'left-recursion', args: ['test/left-recursion.ts'] },
+  { group: 'core', name: 'newline-mode', args: ['test/newline-mode.ts'] },
+  { group: 'core', name: 'interpolation-metadata', args: ['test/interpolation-metadata.ts'] },
   { group: 'core', name: 'refactor-guard', args: ['test/refactor-guard.ts'] },
   { group: 'core', name: 'cst-text-invariant', args: ['test/cst-text-invariant.ts'] },
   { group: 'conformance', name: 'ts-ast-structure', args: ['test/ts-ast-verify.ts'] },
@@ -45,7 +47,6 @@ const GATES: Gate[] = [
   { group: 'highlighter', name: 'angle-depth', args: ['test/angle-depth-probe.ts'] },
   { group: 'highlighter', name: 'html-monarch', args: ['test/html-monarch.ts'] },
   { group: 'highlighter', name: 'html-embed-js', args: ['test/html-embed-js.ts'] },
-  { group: 'highlighter', name: 'html-lexer-spike', args: ['test/html-lexer-spike.ts'] },
   { group: 'highlighter', name: 'self-close-sites', args: ['test/self-close-sites.ts'] },
   { group: 'highlighter', name: 'raw-text-case-sites', args: ['test/raw-text-case-sites.ts'] },
   { group: 'core', name: 'indent-extensions', args: ['test/indent-extensions.ts'] },
diff --git a/test/cpu-profile.ts b/test/cpu-profile.ts
deleted file mode 100644
index 04dc41a..0000000
--- a/test/cpu-profile.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-// Generate a V8 CPU profile of the parser.
-//   npx tsx test/cpu-profile.ts                 # profile the bench corpus (mixed real files)
-//   npx tsx test/cpu-profile.ts <file.ts>       # profile a single file
-//   npx tsx test/cpu-profile.ts <file.ts> 8     # ...for ~8 seconds of samples
-// Writes parser.cpuprofile (open in Chrome DevTools ▸ Performance ▸ Load profile, or VS Code).
-import { Session } from 'node:inspector';
-import { writeFileSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { createParser } from '../src/gen-parser.ts';
-
-const grammar = (await import('../typescript.ts')).default;
-const { parse } = createParser(grammar);
-
-const arg = process.argv[2];
-const seconds = Number(process.argv[3]) || 4;
-
-const corpus = [
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts',
-  '/tmp/ts-repo/tests/cases/conformance/fixSignatureCaching.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/parserRealSource7.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserindenter.ts',
-];
-const paths = arg ? [arg] : corpus;
-const files = paths
-  .map((p) => { try { return readFileSync(p, 'utf-8'); } catch { return null; } })
-  .filter((c): c is string => c !== null);
-
-if (files.length === 0) { console.error('no readable input files:', paths); process.exit(1); }
-const totalKB = (files.reduce((n, c) => n + c.length, 0) / 1024).toFixed(0);
-
-// Warm up so the profile reflects JIT-optimized steady state, not the cold tier.
-for (let r = 0; r < 5; r++) for (const c of files) { try { parse(c); } catch {} }
-
-const session = new Session();
-session.connect();
-const post = (method: string, params?: any) =>
-  new Promise<any>((res, rej) => session.post(method, params, (e: any, r: any) => (e ? rej(e) : res(r))));
-
-await post('Profiler.enable');
-await post('Profiler.setSamplingInterval', { interval: 200 }); // microseconds (5x finer than default)
-await post('Profiler.start');
-
-const start = process.hrtime.bigint();
-let parses = 0;
-while (Number(process.hrtime.bigint() - start) / 1e9 < seconds) {
-  for (const c of files) { try { parse(c); } catch {} parses++; }
-}
-const secs = Number(process.hrtime.bigint() - start) / 1e9;
-
-const { profile } = await post('Profiler.stop');
-const outPath = resolve('parser.cpuprofile');
-writeFileSync(outPath, JSON.stringify(profile));
-
-// Text summary: aggregate self-time (hitCount = samples landing on top of stack) by function.
-const byFn = new Map<string, number>();
-let totalSamples = 0;
-for (const node of profile.nodes) {
-  const hc = node.hitCount || 0;
-  if (!hc) continue;
-  totalSamples += hc;
-  const cf = node.callFrame;
-  const name = cf.functionName || '(anonymous)';
-  const file = (cf.url || '').split('/').pop() || cf.url || '';
-  const where = file ? `${file}:${cf.lineNumber + 1}` : '(native)';
-  const key = `${name.padEnd(22)} ${where}`;
-  byFn.set(key, (byFn.get(key) || 0) + hc);
-}
-const top = [...byFn.entries()].sort((a, b) => b[1] - a[1]).slice(0, 25);
-
-console.log(`\nprofiled ${parses} parses of ${files.length} file(s) (${totalKB} KB/round) in ${secs.toFixed(1)}s`);
-console.log(`${totalSamples} samples @200us\n`);
-console.log(' self%   samples  function @ file:line');
-console.log(' ' + '-'.repeat(60));
-let cum = 0;
-for (const [k, v] of top) {
-  cum += v;
-  console.log(`${(100 * v / totalSamples).toFixed(1).padStart(5)}%  ${String(v).padStart(7)}  ${k}`);
-}
-console.log(` (top 25 = ${(100 * cum / totalSamples).toFixed(0)}% of self-time)`);
-console.log(`\nwrote ${outPath}`);
-console.log('open in Chrome DevTools (Performance ▸ Load profile) or just open the file in VS Code.');
diff --git a/test/emit-parser-bench.ts b/test/emit-parser-bench.ts
deleted file mode 100644
index 5af58a2..0000000
--- a/test/emit-parser-bench.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-// Benchmark: RUNTIME INTERPRETER (createParser, gen-parser.ts) vs the EMITTED
-// specialized parser (emit-parser.ts) on the files where they AGREE — the 4
-// test/bench.ts files (verified byte-identical) plus, optionally, more.
-//
-// Method mirrors test/bench.ts: warm up, then N timed runs, ms/parse per file +
-// the multiplier (interpreter_ms / emitted_ms) per file and aggregate. The lexer
-// is shared (same tokenize), so the delta isolates the PARSER-layer speedup.
-//
-//   node test/emit-parser-bench.ts            # the 4 bench files, N=20
-//   node test/emit-parser-bench.ts <N>        # custom timed-run count
-import { createParser } from '../src/gen-parser.ts';
-import { emitParser, jsTarget } from '../src/emit.ts';
-import { readFileSync, writeFileSync } from 'fs';
-
-const grammar = (await import('../typescript.ts')).default;
-const oracle = createParser(grammar);
-
-const EMITTED = '/tmp/emitted-parser.mts';
-writeFileSync(EMITTED, emitParser(grammar, jsTarget));
-const emitted = await import(EMITTED + '?v=' + Date.now());
-
-const N = Number(process.argv[2]) || 20;
-
-const files = [
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts',
-  '/tmp/ts-repo/tests/cases/conformance/fixSignatureCaching.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/parserRealSource7.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserindenter.ts',
-];
-
-function time(parse: (s: string) => unknown, code: string, n: number): number {
-  const start = process.hrtime.bigint();
-  for (let i = 0; i < n; i++) { try { parse(code); } catch {} }
-  return Number(process.hrtime.bigint() - start) / 1e6 / n;
-}
-
-// Warm up both engines (JIT to steady state) before timing.
-function warm(parse: (s: string) => unknown, code: string) {
-  for (let i = 0; i < 10; i++) { try { parse(code); } catch {} }
-}
-
-console.log(`N=${N} timed runs/engine/file  (lexer is shared → delta = parser layer)\n`);
-console.log('file                          KB   interp ms   emit ms    speedup');
-console.log('-'.repeat(74));
-
-let totInterp = 0, totEmit = 0;
-for (const f of files) {
-  const code = readFileSync(f, 'utf-8');
-  warm(oracle.parse, code);
-  warm(emitted.parse as (s: string) => unknown, code);
-  // Interleave a few rounds and take the best (min) to reduce GC/scheduler noise.
-  let interp = Infinity, emit = Infinity;
-  for (let r = 0; r < 5; r++) {
-    interp = Math.min(interp, time(oracle.parse, code, N));
-    emit = Math.min(emit, time(emitted.parse as (s: string) => unknown, code, N));
-  }
-  totInterp += interp; totEmit += emit;
-  const name = (f.split('/').pop() ?? '').padEnd(28);
-  const kb = (code.length / 1024).toFixed(0).padStart(4);
-  console.log(`${name}${kb}   ${interp.toFixed(2).padStart(8)}   ${emit.toFixed(2).padStart(7)}    ${(interp / emit).toFixed(2)}x`);
-}
-console.log('-'.repeat(74));
-console.log(`${'AGGREGATE'.padEnd(28)}     ${totInterp.toFixed(2).padStart(8)}   ${totEmit.toFixed(2).padStart(7)}    ${(totInterp / totEmit).toFixed(2)}x`);
diff --git a/test/exec-trace.ts b/test/exec-trace.ts
deleted file mode 100644
index 5942b90..0000000
--- a/test/exec-trace.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-// ─────────────────────────────────────────────────────────────────────────────
-//  exec-trace.ts — flattened execution-path tracer (standalone; debug-only).
-//
-//  Prints the ACTUAL source executed between startTrace()/endTrace(), flattened across
-//  call boundaries, with the runtime value of each step and a cost tag — the basis for
-//  op-by-op review of whether each branch/op is minimal.
-//
-//  It does NOT touch the production parser: it AST-instruments a copy (TS compiler API)
-//  so every statement-expression / initializer / return / condition records (line, text,
-//  value, cost) into a buffer gated on a global flag the markers flip. Markers in the real
-//  source (src/trace-markers.ts) are near-free no-ops; here they bound what gets printed.
-//
-//    node test/exec-trace.ts                       # gen-parser.ts on "a + b" (entry Expr)
-//    node test/exec-trace.ts "<input>" <entry>     # custom input / entry rule
-//    node test/exec-trace.ts "<input>" <entry> <src/file.ts>
-// ─────────────────────────────────────────────────────────────────────────────
-import ts from 'typescript';
-import { readFileSync, writeFileSync } from 'fs';
-import { dirname, resolve } from 'path';
-import { pathToFileURL } from 'url';
-
-const REPO = resolve(import.meta.dirname, '..');
-const args = process.argv.slice(2);
-const pos = args.filter(a => !a.startsWith('--'));
-const input = pos[0] ?? 'a + b';
-const entry = pos[1] ?? 'Expr';
-const target = resolve(REPO, pos[2] ?? 'src/gen-parser.ts');
-// Optional spatial scope: only record ops on lines A..B (focus on a region without
-// editing the source; the time-region startTrace/endTrace markers are the other knob).
-const linesArg = args.find(a => a.startsWith('--lines='));
-const [LO, HI] = linesArg ? linesArg.slice(8).split('-').map(Number) : [0, Infinity];
-
-// ── 1) cost classification (transform-time) ──
-function costOf(node: ts.Node): string {
-  let cost = '';
-  const scan = (n: ts.Node): void => {
-    if (cost) return;
-    if (ts.isFunctionExpression(n) || ts.isArrowFunction(n)) return;        // don't peer into nested fns
-    if (ts.isNewExpression(n) || ts.isObjectLiteralExpression(n) || ts.isArrayLiteralExpression(n)) { cost = 'alloc'; return; }
-    if (ts.isCallExpression(n)) {
-      const callee = n.expression;
-      if (ts.isPropertyAccessExpression(callee) && /^(get|set|has|add|delete)$/.test(callee.name.text)) cost = `map.${callee.name.text}`;
-      else cost = 'call';
-      return;
-    }
-    ts.forEachChild(n, scan);
-  };
-  ts.forEachChild(node, scan);
-  if (!cost && (ts.isNewExpression(node) || ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node))) cost = 'alloc';
-  return cost;
-}
-
-// ── 2) instrument ──
-const source = readFileSync(target, 'utf-8');
-const sf = ts.createSourceFile(target, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-const lineOf = (n: ts.Node) => sf.getLineAndCharacterOfPosition(n.getStart(sf)).line + 1;
-const textOf = (n: ts.Node) => {
-  // For a declaration show `name = init` (drop the `: Type` annotation — pure noise).
-  let raw = ts.isVariableDeclaration(n) ? `${n.name.getText(sf)} = ${n.initializer ? n.initializer.getText(sf) : ''}` : n.getText(sf);
-  raw = raw.replace(/\s+/g, ' ');
-  return raw.length > 64 ? raw.slice(0, 63) + '…' : raw;
-};
-
-const transformer: ts.TransformerFactory<ts.SourceFile> = (context) => {
-  const f = context.factory;
-  const G = (m: string) => f.createPropertyAccessExpression(f.createIdentifier('globalThis'), m);
-  const num = (n: number) => f.createNumericLiteral(n);
-  const str = (s: string) => f.createStringLiteral(s);
-  // __recv(line, text, cost, expr) → records the value, returns expr unchanged (single eval).
-  const recv = (l: number, t: string, c: string, e: ts.Expression) =>
-    f.createCallExpression(G('__recv'), undefined, [num(l), str(t), str(c), e]);
-  const recc = (l: number, t: string, e: ts.Expression) =>
-    f.createCallExpression(G('__recc'), undefined, [num(l), str(t), e]);
-  const enterStmt = (l: number, name: string) =>
-    f.createExpressionStatement(f.createCallExpression(G('__enter'), undefined, [num(l), str(name)]));
-  const exitStmt = (l: number) =>
-    f.createExpressionStatement(f.createCallExpression(G('__exit'), undefined, [num(l)]));
-
-  const isFnExpr = (e: ts.Expression) => ts.isArrowFunction(e) || ts.isFunctionExpression(e);
-
-  const visit = (node: ts.Node): ts.Node => {
-    // capture original line/text BEFORE children are replaced
-    if (ts.isExpressionStatement(node)) {
-      const l = lineOf(node.expression), t = textOf(node.expression), c = costOf(node.expression);
-      const v = ts.visitEachChild(node, visit, context);
-      return f.updateExpressionStatement(v, recv(l, t, c, v.expression));
-    }
-    if (ts.isVariableDeclaration(node) && node.initializer && !isFnExpr(node.initializer)) {
-      const l = lineOf(node), t = textOf(node), c = costOf(node.initializer);
-      const v = ts.visitEachChild(node, visit, context) as ts.VariableDeclaration;
-      return f.updateVariableDeclaration(v, v.name, v.exclamationToken, v.type, recv(l, t, c, v.initializer!));
-    }
-    if (ts.isReturnStatement(node) && node.expression) {
-      const l = lineOf(node), t = textOf(node), c = costOf(node.expression);
-      const v = ts.visitEachChild(node, visit, context) as ts.ReturnStatement;
-      return f.updateReturnStatement(v, recv(l, t, c, v.expression!));
-    }
-    if (ts.isIfStatement(node)) {
-      const l = lineOf(node.expression), t = textOf(node.expression);
-      const v = ts.visitEachChild(node, visit, context) as ts.IfStatement;
-      return f.updateIfStatement(v, recc(l, t, v.expression), v.thenStatement, v.elseStatement);
-    }
-    if (ts.isWhileStatement(node)) {
-      const l = lineOf(node.expression), t = textOf(node.expression);
-      const v = ts.visitEachChild(node, visit, context) as ts.WhileStatement;
-      return f.updateWhileStatement(v, recc(l, t, v.expression), v.statement);
-    }
-    // Frame boundaries (named function declarations — the parser's functions): enter marker
-    // + try/finally exit so every call is exactly one balanced ▸…◂ frame (early returns,
-    // throws, fall-through all hit the finally). Gated on the FN's line so a --lines scope
-    // drops a frame's enter+exit together (stays balanced).
-    if (ts.isFunctionDeclaration(node) && node.body && node.name) {
-      const l = lineOf(node), name = node.name.text;
-      const v = ts.visitEachChild(node, visit, context) as ts.FunctionDeclaration;
-      const tryFin = f.createTryStatement(f.createBlock(v.body!.statements, true), undefined, f.createBlock([exitStmt(l)], true));
-      const body = f.createBlock([enterStmt(l, name), tryFin], true);
-      return f.updateFunctionDeclaration(v, v.modifiers, v.asteriskToken, v.name, v.typeParameters, v.parameters, v.type, body);
-    }
-    return ts.visitEachChild(node, visit, context);
-  };
-  return (root) => ts.visitNode(root, visit) as ts.SourceFile;
-};
-
-const result = ts.transform(sf, [transformer]);
-let printed = ts.createPrinter().printFile(result.transformed[0]);
-// absolutize relative imports so the /tmp copy resolves the real sibling modules
-printed = printed.replace(/from\s+(['"])(\.\.?\/[^'"]+)\1/g, (_m, q, p) => `from ${q}${resolve(dirname(target), p)}${q}`);
-
-const outPath = '/tmp/exec-trace-instrumented.ts';
-writeFileSync(outPath, printed);
-
-// ── 3) record runtime ──
-type Ev =
-  | { kind: 'op'; l: number; t: string; c: string; v?: string }
-  | { kind: 'enter'; l: number; fn: string }
-  | { kind: 'exit'; l: number };
-const TRACE: Ev[] = [];
-const g = globalThis as Record<string, unknown>;
-g.__REC = false;
-g.__TRACE = TRACE;
-function fmt(v: unknown): string {
-  if (v === null) return '∅';
-  if (v === undefined) return '⊥';
-  if (typeof v === 'boolean' || typeof v === 'number') return String(v);
-  if (typeof v === 'string') return v.length > 24 ? JSON.stringify(v.slice(0, 24)) + '…' : JSON.stringify(v);
-  if (Array.isArray(v)) return `[${v.length}]`;
-  if (v instanceof Map) return `Map(${v.size})`;
-  if (v instanceof Set) return `Set(${v.size})`;
-  if (typeof v === 'object') {
-    const o = v as Record<string, unknown>;
-    if (o.tokenType !== undefined) return `${o.tokenType}@${o.offset}..${o.end}`;
-    if (o.rule !== undefined) return `node(${o.rule})`;
-    if ('type' in o && 'text' in o) return `${o.type || 'punct'}'${o.text}'`;
-    return `{${Object.keys(o).slice(0, 4).join(',')}}`;
-  }
-  if (typeof v === 'function') return 'fn';
-  return String(v);
-}
-const on = (l: number) => g.__REC && l >= LO && l <= HI;
-g.__recv = (l: number, t: string, c: string, v: unknown) => { if (on(l)) TRACE.push({ kind: 'op', l, t, c, v: fmt(v) }); return v; };
-g.__recc = (l: number, t: string, v: unknown) => { if (on(l)) TRACE.push({ kind: 'op', l, t, c: 'cond', v: fmt(v) }); return v; };
-g.__enter = (l: number, fn: string) => { if (on(l)) TRACE.push({ kind: 'enter', l, fn }); };
-g.__exit = (l: number) => { if (on(l)) TRACE.push({ kind: 'exit', l }); };
-
-const mod = await import(pathToFileURL(outPath).href);
-const grammar = (await import(pathToFileURL(resolve(REPO, 'typescript.ts')).href)).default;
-const parser = mod.createParser(grammar);
-
-g.__REC = true;
-let err: string | null = null;
-try { parser.parse(input, entry); } catch (e) { err = (e as Error).message; }
-g.__REC = false;
-
-// ── 4) build frame tree → group by DISTINCT execution path → render ──
-const fileName = target.replace(REPO + '/', '');
-const ops = TRACE.filter((e): e is Extract<Ev, { kind: 'op' }> => e.kind === 'op');
-const allocs = ops.filter(e => e.c === 'alloc').length;
-const mapset = ops.filter(e => e.c.startsWith('map.')).length;
-const conds = ops.filter(e => e.c === 'cond').length;
-const calls = TRACE.filter(e => e.kind === 'enter').length;
-
-type OpN = { op: true; l: number; t: string; c: string; vs: (string | undefined)[]; n: number };
-type FrameN = { op: false; fn: string; l: number; items: Node[]; n: number };
-type Node = OpN | FrameN;
-
-// events → tree (enter pushes a frame, exit pops; try/finally keeps them balanced)
-const root: FrameN = { op: false, fn: '(root)', l: 0, items: [], n: 1 };
-const stack: FrameN[] = [root];
-for (const e of TRACE) {
-  const top = stack[stack.length - 1];
-  if (e.kind === 'enter') { const fr: FrameN = { op: false, fn: e.fn, l: e.l, items: [], n: 1 }; top.items.push(fr); stack.push(fr); }
-  else if (e.kind === 'exit') { if (stack.length > 1) stack.pop(); }
-  else top.items.push({ op: true, l: e.l, t: e.t, c: e.c, vs: [e.v], n: 1 });
-}
-
-// path signature: same path ⇔ same op/frame structure (values excluded — they aggregate)
-const sig = (n: Node): string => n.op ? `o${n.l}:${n.t}` : `f${n.fn}:${n.l}(${n.items.map(sig).join(',')})`;
-// merge same-signature nodes: concat op value-lists, recurse frames position-wise (same sig ⇒ same shape)
-function merge(ns: Node[]): Node {
-  const total = ns.reduce((s, x) => s + x.n, 0);
-  if (ns[0].op) { const f = ns[0]; return { op: true, l: f.l, t: f.t, c: f.c, vs: (ns as OpN[]).flatMap(x => x.vs), n: total }; }
-  const f0 = ns[0] as FrameN;
-  return { op: false, fn: f0.fn, l: f0.l, items: f0.items.map((_, i) => merge((ns as FrameN[]).map(x => x.items[i]))), n: total };
-}
-// group a sibling list by signature (first-occurrence order), then recurse into frames
-function group(items: Node[]): Node[] {
-  const order: string[] = []; const by = new Map<string, Node[]>();
-  for (const it of items) { const s = sig(it); if (!by.has(s)) { by.set(s, []); order.push(s); } by.get(s)!.push(it); }
-  return order.map(s => { const m = merge(by.get(s)!); if (!m.op) m.items = group(m.items); return m; });
-}
-
-const valDist = (vs: (string | undefined)[]) => {
-  if (vs[0] === undefined) return '';
-  const c = new Map<string, number>();
-  for (const v of vs) c.set(v!, (c.get(v!) ?? 0) + 1);
-  return c.size === 1 ? ` → ${[...c.keys()][0]}` : ` → ${[...c].map(([v, k]) => `${v}×${k}`).join(' ')}`;
-};
-const out: string[] = [];
-const render = (ns: Node[], d: number) => {
-  const ind = '  '.repeat(d);
-  for (const n of ns) {
-    const rep = n.n > 1 ? ` ×${n.n}` : '';
-    if (n.op) out.push(`${ind}${n.l} ${n.t}${valDist(n.vs)}${n.c && n.c !== 'cond' ? ` {${n.c}}` : ''}${rep}`);
-    else { out.push(`${ind}▸${n.fn}${rep}`); render(n.items, d + 1); }
-  }
-};
-render(group(root.items), 0);
-
-console.log(`═ ${fileName} · ${JSON.stringify(input)} (entry ${entry}) ═`);
-console.log(`summary: ${TRACE.length} ops · ${calls} calls · ${allocs} alloc · ${mapset} map/set · ${conds} cond${err ? ` · ERROR ${err}` : ''}`);
-console.log(`fmt: [indent=call depth] line source → value(×N if varies) {cost} · ▸fn ×N = N calls, one DISTINCT path  (bare line=${fileName})`);
-console.log(out.join('\n'));
diff --git a/test/html-embed-js.ts b/test/html-embed-js.ts
index 3a73088..794c80a 100644
--- a/test/html-embed-js.ts
+++ b/test/html-embed-js.ts
@@ -131,6 +131,10 @@ if (existsSync(OFFICIAL)) {
   console.log(`\nBoundary vs official (both embedding Monogram's JS), <script> only, ${cases.length} cases:`);
   console.log(`  ${agree}/${total} chars delegated to source.js identically (${(100 * agree / total).toFixed(1)}%)`);
   if (diffs.length) { console.log('  where they differ:'); for (const d of diffs) console.log(d); }
+  // Ratchet: the known divergences are the 5 chars where the official grammar starts
+  // source.js immediately after `<script ...>` while Monogram starts at the first token.
+  // Regressions below this floor are real boundary bugs.
+  check(`official-boundary ratchet (${agree}/${total} ≥ 216/221)`, agree >= 216 && total === 221);
 } else {
   console.log(`\n⊘ official HTML grammar not found — skipping the boundary comparison.`);
 }
diff --git a/test/monarch-smoke.ts b/test/monarch-smoke.ts
deleted file mode 100644
index 3a90543..0000000
--- a/test/monarch-smoke.ts
+++ /dev/null
@@ -1,209 +0,0 @@
-// Structural smoke test for gen-monarch: generate the Monaco *Monarch* tokenizer
-// from the TypeScript grammar and sanity-check the resulting object WITHOUT
-// installing monaco. We validate it the way Monarch itself would consume it:
-//   • the object shape (tokenizer/states/brackets/defaultToken)
-//   • every `next`/`switchTo`/`include` resolves to a real state or builtin
-//   • every rule regex compiles as a *JavaScript* RegExp (proves no Oniguruma)
-//   • the headline features: preceding-context regex-vs-division, generics as a
-//     type-argument state, and template `${}` interpolation via a state stack
-// Plus a tiny non-TS grammar to prove the generator stays language-agnostic.
-//
-// Run with bare `node test/monarch-smoke.ts`.
-import { generateMonarch, type MonarchLanguage, type MonarchRule, type MonarchAction } from '../src/gen-monarch.ts';
-import { token, rule, defineGrammar, alt, many, left, seq, plus, oneOf, range, star, noneOf } from '../src/api.ts';
-
-let ok = 0, fail = 0;
-const check = (label: string, cond: boolean) => { cond ? ok++ : (fail++, console.log('  ✗', label)); };
-
-const grammar = (await import('../typescript.ts')).default;
-const mon: MonarchLanguage = generateMonarch(grammar);
-const digit = range('0', '9');
-
-// ── Helpers to walk the generated tokenizer ──
-const BUILTIN_TARGETS = new Set(['@pop', '@popall', '@push', '@rematch']);
-
-function actionTargets(a: MonarchAction): string[] {
-  if (!a || typeof a !== 'object') return [];
-  if ('cases' in a) return Object.values(a.cases).flatMap(actionTargets);
-  const out: string[] = [];
-  if ('next' in a && a.next) out.push(a.next);
-  if ('switchTo' in a && a.switchTo) out.push(a.switchTo);
-  return out;
-}
-function ruleTargets(r: MonarchRule): string[] {
-  if (!Array.isArray(r)) return [r.include];
-  const out = actionTargets(r[1]);
-  if (r.length === 3 && typeof r[2] === 'string') out.push(r[2]);
-  return out;
-}
-function eachArrayRule(fn: (state: string, r: Extract<MonarchRule, unknown[]>) => void) {
-  for (const [state, rules] of Object.entries(mon.tokenizer))
-    for (const r of rules) if (Array.isArray(r)) fn(state, r);
-}
-
-// Resolve a state's rules the way Monarch does — flattening `{ include }`
-// references transitively — so assertions don't depend on whether a rule lives
-// directly in a state or in an included sub-state.
-function rulesOf(state: string, seen = new Set<string>()): Extract<MonarchRule, unknown[]>[] {
-  if (seen.has(state)) return [];
-  seen.add(state);
-  const out: Extract<MonarchRule, unknown[]>[] = [];
-  for (const r of mon.tokenizer[state] ?? []) {
-    if (Array.isArray(r)) out.push(r);
-    else out.push(...rulesOf(r.include.replace(/^@/, ''), seen));
-  }
-  return out;
-}
-function findInState(state: string, pred: (r: Extract<MonarchRule, unknown[]>) => boolean) {
-  return rulesOf(state).find(pred);
-}
-
-// ── 1. Top-level object shape ──
-check('defaultToken is set', typeof mon.defaultToken === 'string' && mon.defaultToken.length > 0);
-check('tokenPostfix derived from grammar name', mon.tokenPostfix === '.typescript');
-check('has tokenizer object', mon.tokenizer && typeof mon.tokenizer === 'object');
-check('has root state', Array.isArray(mon.tokenizer.root));
-check('has value state (the value-position mode)', Array.isArray(mon.tokenizer.value));
-check('brackets derived from punctuation.bracket.* scopes', mon.brackets.length === 3);
-check('brackets include round/curly/square pairs',
-  mon.brackets.some(b => b.open === '(' && b.close === ')') &&
-  mon.brackets.some(b => b.open === '{' && b.close === '}') &&
-  mon.brackets.some(b => b.open === '[' && b.close === ']'));
-
-// ── 2. Every state reference resolves ──
-const states = new Set(Object.keys(mon.tokenizer));
-let dangling = 0;
-for (const [, rules] of Object.entries(mon.tokenizer))
-  for (const r of rules)
-    for (const t of ruleTargets(r))
-      if (t.startsWith('@') && !BUILTIN_TARGETS.has(t) && !states.has(t.slice(1))) dangling++;
-check('no dangling state references', dangling === 0);
-check('include targets exist', [...states].length > 0);
-
-// ── 3. Every rule regex compiles as a JS RegExp (NO Oniguruma) ──
-let badRegex = 0;
-let onigurumaConstructs = 0;
-eachArrayRule((_s, r) => {
-  try { new RegExp(r[0]); } catch { badRegex++; }
-  // Oniguruma-only constructs that must NOT appear: recursive subpattern \g<..>,
-  // named-group backrefs \k<..>, possessive quantifiers, atomic groups (?>..).
-  if (/\\g<|\\k<|[*+?]\+|\(\?>/.test(r[0])) onigurumaConstructs++;
-});
-check('all rule regexes compile as JavaScript RegExp', badRegex === 0);
-check('no Oniguruma-only regex constructs', onigurumaConstructs === 0);
-
-// ── 4. Regex-vs-division by PRECEDING context ──
-// In expression position (`root`) a leading `/` starts a regex literal; in value
-// position (`value`) `/` is the division operator. This is the win over Monaco's
-// follow-heuristic.
-function findRule(state: string, pred: (r: Extract<MonarchRule, unknown[]>) => boolean) {
-  return (mon.tokenizer[state] as MonarchRule[]).find((r): r is Extract<MonarchRule, unknown[]> =>
-    Array.isArray(r) && pred(r));
-}
-const rootRegex = findRule('root', r => {
-  const a = r[1];
-  return typeof a === 'object' && 'token' in a && a.token === 'regexp';
-});
-check('root (expression position) tokenizes a regex literal', !!rootRegex);
-const valueSlash = findRule('value', r => /\//.test(r[0]) && !/regexp/.test(JSON.stringify(r[1])));
-check('value (value position) treats / as the division operator',
-  !!valueSlash && JSON.stringify(valueSlash[1]).includes('operator'));
-// Sanity: the regex-literal rule actually matches a real regex and rejects a
-// division context (compiled and run here as Monarch would at the cursor).
-if (rootRegex) {
-  const re = new RegExp('^(?:' + rootRegex[0] + ')');
-  check('regex-literal rule matches /ab+c/gi', re.test('/ab+c/gi'));
-  check('regex-literal rule does NOT match a bare /', !re.test('/ '));
-}
-
-// ── 5. Generics as a type-argument state (context-based type.identifier) ──
-check('has a typeargs state', Array.isArray(mon.tokenizer.typeargs));
-const typeIdentRule = findRule('typeargs', r => JSON.stringify(r[1]).includes('type.identifier'));
-check('typeargs emits type.identifier for bare identifiers (beats capitalization heuristic)', !!typeIdentRule);
-// The value-position `<` is GUARDED so only a real generic-arg list opens it.
-const guardedAngle = findRule('value', r => r[0].startsWith('<') && JSON.stringify(r[1]).includes('typeargs'));
-check('value-position `<` is guarded and opens the typeargs state', !!guardedAngle);
-if (guardedAngle) {
-  const re = new RegExp('^(?:' + guardedAngle[0] + ')');
-  check('guard ACCEPTS a generic call  f<T>(…)', re.test('<T>(x)'));
-  check('guard ACCEPTS a generic call  f<A, B>(…)', re.test('<A, B>(x)'));
-  check('guard ACCEPTS one nested level f<Map<K,V>>(…)', re.test('<Map<K, V>>(x)'));
-  check('guard ACCEPTS a tagged template f<T>`…`', re.test('<T>`x`'));
-  check('guard REJECTS a comparison     a < b', !re.test('< b'));
-  check('guard REJECTS chained compare  a < b > c (no confirm)', !re.test('< b > c'));
-  check('guard REJECTS the <= operator', !re.test('<= 3'));
-}
-// In expression position a bare `<`/`>` is a comparison operator (like Monaco).
-const exprComparison = findRule('root', r => r[0] === '<|>');
-check('expression-position `<`/`>` is a comparison operator', !!exprComparison);
-
-// ── 6. Template `${}` interpolation via a state stack (incl. nesting) ──
-check('has a template state', Array.isArray(mon.tokenizer.template));
-check('has a templateInterp state (the `${ … }` hole)', Array.isArray(mon.tokenizer.templateInterp));
-check('has a bracketCounting state (nested `{}` inside a hole)', Array.isArray(mon.tokenizer.bracketCounting));
-check('has a nested-template state for templates inside `${}` (state-stack nesting)',
-  Array.isArray(mon.tokenizer.templateN));
-check('has a nested-string state for strings inside `${}`',
-  Object.keys(mon.tokenizer).some(s => /^string_.*N$/.test(s)));
-// The hole opens with `${` pushing the interpolation state, and closes with `}` popping.
-const interpOpen = findInState('template', r => JSON.stringify(r).includes('templateInterp'));
-check('template body pushes the interpolation state on `${`', !!interpOpen);
-const interpClose = findRule('templateInterp', r => r[0].includes('}') && JSON.stringify(r[1]).includes('@pop'));
-check('interpolation hole pops back to the template on the closing `}`', !!interpClose);
-
-// ── 7. Keyword / built-in dispatch via `cases` ──
-const identCasesRule = findInState('root', r =>
-  typeof r[1] === 'object' && 'cases' in r[1]);
-check('root has an identifier rule with a `cases` dispatch', !!identCasesRule);
-if (identCasesRule && typeof identCasesRule[1] === 'object' && 'cases' in identCasesRule[1]) {
-  const cases = identCasesRule[1].cases;
-  const tokenOf = (a: MonarchAction | undefined) =>
-    a && typeof a === 'object' && 'token' in a ? a.token : a;
-  check('control keyword `if` → keyword', tokenOf(cases['if']) === 'keyword');
-  check('primitive type `string` → keyword', tokenOf(cases['string']) === 'keyword');
-  check('built-in class `Promise` → type.identifier (a type reference)',
-    tokenOf(cases['Promise']) === 'type.identifier');
-  check('built-in value `console` → variable', tokenOf(cases['console']) === 'variable');
-  check('a plain identifier falls through to the default → identifier',
-    tokenOf(cases['@default']) === 'identifier');
-}
-
-// ── 8. Comments derived from skip tokens (line + block, block spans lines) ──
-check('has at least one block-comment state', Object.keys(mon.tokenizer).some(s => s.startsWith('comment_')));
-const lineComment = findInState('root', r => r[0].includes('//') && r[0].endsWith('$'));
-check('line comment runs to end of line', !!lineComment);
-
-// ── 9. Language-agnosticism — a tiny grammar named NOTHING like TS, with NO
-//      template / regex / backtick, must still produce a valid tokenizer and
-//      must NOT fabricate template/regex/generics states it has no basis for. ──
-const Word = token(plus(range('a', 'z')), { identifier: true });
-const Num = token(plus(digit));
-const Str = token(seq('~', star(noneOf('~')), '~'), { string: true });
-const Mini = rule(($: any) => [many(alt(Word, Num, Str, '+'))]);
-const mini = defineGrammar({
-  name: 'mini',
-  tokens: { Word, Num, Str },
-  prec: [left('+')],
-  rules: { Mini },
-  scopes: { 'keyword.operator.arithmetic': ['+'] },
-  entry: Mini,
-});
-const miniMon = generateMonarch(mini);
-check('agnostic: tiny grammar produces a tokenizer', !!miniMon.tokenizer.root);
-check('agnostic: tokenPostfix uses the declared name (.mini)', miniMon.tokenPostfix === '.mini');
-check('agnostic: NO template state when no template token is declared',
-  !('template' in miniMon.tokenizer) && !('templateInterp' in miniMon.tokenizer));
-check('agnostic: NO typeargs state when the grammar has no generics',
-  !('typeargs' in miniMon.tokenizer));
-check('agnostic: string state derived from the `~…~` token (not hardcoded quotes)',
-  Object.keys(miniMon.tokenizer).some(s => s.startsWith('string_')));
-// Every mini regex still compiles as a JS RegExp.
-let miniBad = 0;
-for (const rules of Object.values(miniMon.tokenizer))
-  for (const r of rules) if (Array.isArray(r)) { try { new RegExp(r[0]); } catch { miniBad++; } }
-check('agnostic: all mini regexes compile as JS RegExp', miniBad === 0);
-
-console.log(fail === 0
-  ? `\n${ok}/${ok} Monarch smoke checks pass`
-  : `\n${fail} FAILED (of ${ok + fail})`);
-process.exit(fail === 0 ? 0 : 1);
diff --git a/test/oxc-parse-bench/Cargo.lock b/test/oxc-parse-bench/Cargo.lock
deleted file mode 100644
index 75bc985..0000000
--- a/test/oxc-parse-bench/Cargo.lock
+++ /dev/null
@@ -1,552 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
-[[package]]
-name = "autocfg"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
-
-[[package]]
-name = "bitflags"
-version = "2.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
-
-[[package]]
-name = "castaway"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
-dependencies = [
- "rustversion",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
-
-[[package]]
-name = "compact_str"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dfdd1c2274d9aa354115b09dc9a901d6c5576818cdf70d14cae2bdb47df00ab"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
-]
-
-[[package]]
-name = "cow-utils"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "417bef24afe1460300965a25ff4a24b8b45ad011948302ec221e8a0a81eb2c79"
-
-[[package]]
-name = "dragonbox_ecma"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd8e701084c37e7ef62d3f9e453b618130cbc0ef3573847785952a3ac3f746bf"
-
-[[package]]
-name = "fastrand"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
-
-[[package]]
-name = "hashbrown"
-version = "0.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
-dependencies = [
- "allocator-api2",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
-
-[[package]]
-name = "memchr"
-version = "2.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
-
-[[package]]
-name = "nonmax"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "610a5acd306ec67f907abe5567859a3c693fb9886eb1f012ab8f2a47bef3db51"
-
-[[package]]
-name = "num-bigint"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "owo-colors"
-version = "4.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d211803b9b6b570f68772237e415a029d5a50c65d382910b879fb19d3271f94d"
-
-[[package]]
-name = "oxc-miette"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4356a61f2ed4c9b3610245215fbf48970eb277126919f87db9d0efa93a74245c"
-dependencies = [
- "cfg-if",
- "owo-colors",
- "oxc-miette-derive",
- "textwrap",
- "thiserror",
- "unicode-segmentation",
- "unicode-width",
-]
-
-[[package]]
-name = "oxc-miette-derive"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b237422b014f8f8fff75bb9379e697d13f8d57551a22c88bebb39f073c1bf696"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "oxc-parse-bench"
-version = "0.1.0"
-dependencies = [
- "oxc_allocator",
- "oxc_parser",
- "oxc_span",
-]
-
-[[package]]
-name = "oxc_allocator"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e54dd7c5eb0fa364f0b7ca09109f21cede0ae5f72001163170d954d62a0e4e86"
-dependencies = [
- "allocator-api2",
- "hashbrown",
- "oxc_data_structures",
- "rustc-hash",
-]
-
-[[package]]
-name = "oxc_ast"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7391676b3f06b7cb8e720ec06daf052395bb7516a8b647992ce5a21ea997989"
-dependencies = [
- "bitflags",
- "oxc_allocator",
- "oxc_ast_macros",
- "oxc_data_structures",
- "oxc_diagnostics",
- "oxc_estree",
- "oxc_regular_expression",
- "oxc_span",
- "oxc_str",
- "oxc_syntax",
-]
-
-[[package]]
-name = "oxc_ast_macros"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6b396cf8aefca1f06445b28e434b16529b199bbb8a6157c905d7b5e4dfae90"
-dependencies = [
- "phf",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "oxc_data_structures"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fdea5ebbfe376448e83f9749828f31a0ad9b85a1b01e31f70597565b74f809a"
-
-[[package]]
-name = "oxc_diagnostics"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5ac2365c7cf9255776ceb41310c90d9e636586cf291ae9c0df50028f559837b"
-dependencies = [
- "cow-utils",
- "oxc-miette",
- "percent-encoding",
-]
-
-[[package]]
-name = "oxc_ecmascript"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "651a4509f2de47c7e49fc3a78e136e821062c4d97d2544c6336dda0f4513cfc6"
-dependencies = [
- "cow-utils",
- "num-bigint",
- "num-traits",
- "oxc_allocator",
- "oxc_ast",
- "oxc_regular_expression",
- "oxc_span",
- "oxc_syntax",
-]
-
-[[package]]
-name = "oxc_estree"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e891d31bbe5e6c3a849a2db7de16015076f0d83f42110ace1fdfd7d2e886b97c"
-
-[[package]]
-name = "oxc_index"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb3e6120999627ec9703025eab7c9f410ebb7e95557632a8902ca48210416c2b"
-dependencies = [
- "nonmax",
- "serde",
-]
-
-[[package]]
-name = "oxc_parser"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ab4ee6b100bedfd125cfbd9747e921984d6adab212b73affecc29a46df4bf15"
-dependencies = [
- "bitflags",
- "cow-utils",
- "memchr",
- "num-bigint",
- "num-traits",
- "oxc_allocator",
- "oxc_ast",
- "oxc_data_structures",
- "oxc_diagnostics",
- "oxc_ecmascript",
- "oxc_regular_expression",
- "oxc_span",
- "oxc_str",
- "oxc_syntax",
- "rustc-hash",
- "seq-macro",
-]
-
-[[package]]
-name = "oxc_regular_expression"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "896df45fde44d336df10d3cab46c0cc58697ffa69d446ca4a1b278b8c582972a"
-dependencies = [
- "bitflags",
- "oxc_allocator",
- "oxc_ast_macros",
- "oxc_diagnostics",
- "oxc_span",
- "oxc_str",
- "phf",
- "rustc-hash",
- "unicode-id-start",
-]
-
-[[package]]
-name = "oxc_span"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5778776c8d0ed52822841324e0dd08c024a3fc1e6dd45895e129dbb14f33f2a"
-dependencies = [
- "compact_str",
- "oxc-miette",
- "oxc_allocator",
- "oxc_ast_macros",
- "oxc_estree",
- "oxc_str",
-]
-
-[[package]]
-name = "oxc_str"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc120670ba73a00a9d1412de98ac63b2907551707fe4063d96ee2e44cc75ab56"
-dependencies = [
- "compact_str",
- "hashbrown",
- "oxc_allocator",
- "oxc_estree",
-]
-
-[[package]]
-name = "oxc_syntax"
-version = "0.126.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13ca07418ff23061b0be35b8f3ed43291bf29ad23aeb51a0faff71c5acc751c0"
-dependencies = [
- "bitflags",
- "cow-utils",
- "dragonbox_ecma",
- "nonmax",
- "oxc_allocator",
- "oxc_ast_macros",
- "oxc_estree",
- "oxc_index",
- "oxc_span",
- "oxc_str",
- "phf",
- "unicode-id-start",
-]
-
-[[package]]
-name = "percent-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
-
-[[package]]
-name = "phf"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
-dependencies = [
- "phf_macros",
- "phf_shared",
- "serde",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
-dependencies = [
- "fastrand",
- "phf_shared",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
-dependencies = [
- "phf_generator",
- "phf_shared",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rustc-hash"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
-
-[[package]]
-name = "rustversion"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
-
-[[package]]
-name = "ryu"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
-
-[[package]]
-name = "seq-macro"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
-
-[[package]]
-name = "serde"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
-dependencies = [
- "serde_core",
-]
-
-[[package]]
-name = "serde_core"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.228"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "siphasher"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
-
-[[package]]
-name = "smawk"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8e2fb0f499abb4d162f2bedad68f5ef91a1682b5a03596ddb67efd37768d100"
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "syn"
-version = "2.0.118"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "textwrap"
-version = "0.16.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
-dependencies = [
- "smawk",
- "unicode-linebreak",
- "unicode-width",
-]
-
-[[package]]
-name = "thiserror"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "unicode-id-start"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81b79ad29b5e19de4260020f8919b443b2ef0277d242ce532ec7b7a2cc8b6007"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
-
-[[package]]
-name = "unicode-linebreak"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
-
-[[package]]
-name = "unicode-segmentation"
-version = "1.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8"
-
-[[package]]
-name = "unicode-width"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
diff --git a/test/oxc-parse-bench/Cargo.toml b/test/oxc-parse-bench/Cargo.toml
deleted file mode 100644
index 2e2ec4f..0000000
--- a/test/oxc-parse-bench/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-# Native oxc parser bench for test/profile-portable-peers.mjs (stdin → N → ms/iter).
-# Pinned to oxc 0.126 (rustc 1.92+). oxc 0.137 needs rustc 1.94 — bump versions after upgrading.
-[package]
-name = "oxc-parse-bench"
-version = "0.1.0"
-edition = "2021"
-rust-version = "1.92"
-
-[dependencies]
-oxc_allocator = "0.126.0"
-oxc_parser = { version = "0.126.0", features = ["regular_expression"] }
-oxc_span = "0.126.0"
diff --git a/test/oxc-parse-bench/src/main.rs b/test/oxc-parse-bench/src/main.rs
deleted file mode 100644
index 748a6ac..0000000
--- a/test/oxc-parse-bench/src/main.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Native oxc parse bench — same stdin + N-arg protocol as Monogram rustTarget emitRunner.
-use std::io::Read;
-
-use oxc_allocator::Allocator;
-use oxc_parser::{ParseOptions, Parser};
-use oxc_span::SourceType;
-
-fn parse(src: &str, allocator: &Allocator) {
-    let ret = Parser::new(allocator, src, SourceType::mjs())
-        .with_options(ParseOptions {
-            parse_regular_expression: true,
-            ..ParseOptions::default()
-        })
-        .parse();
-    std::hint::black_box(ret.program);
-}
-
-fn main() {
-    let mut src = String::new();
-    std::io::stdin().read_to_string(&mut src).unwrap();
-    let mut allocator = Allocator::default();
-
-    if let Some(iters) = std::env::args().nth(1).and_then(|a| a.parse::<u64>().ok()) {
-        for _ in 0..3 {
-            allocator.reset();
-            parse(&src, &allocator);
-        }
-        let t = std::time::Instant::now();
-        for _ in 0..iters {
-            allocator.reset();
-            parse(&src, &allocator);
-        }
-        println!("{:.4}", t.elapsed().as_secs_f64() * 1000.0 / iters as f64);
-        return;
-    }
-
-    parse(&src, &allocator);
-}
diff --git a/test/profile-lines.mjs b/test/profile-lines.mjs
deleted file mode 100644
index 63a2bc2..0000000
Binary files a/test/profile-lines.mjs and /dev/null differ
diff --git a/test/profile-portable-peers.mjs b/test/profile-portable-peers.mjs
deleted file mode 100644
index 3ada135..0000000
--- a/test/profile-portable-peers.mjs
+++ /dev/null
@@ -1,219 +0,0 @@
-// Portable-target peer benchmarks (methodology: profile-vs-tsc.mjs / profile-vs-peers.mjs)
-//   tsTarget (typescript.ts)     vs tsc createSourceFile
-//   goTarget (javascript.ts)       vs typescript-go parser.ParseSourceFile
-//   rustTarget (javascript.ts)   vs oxc native (oxc_parser crate) AND oxc npm (parseSync)
-//   node test/profile-portable-peers.mjs
-//
-// Prerequisites:
-//   - go, rustc 1.92+
-//   - git clone --depth 1 https://github.com/microsoft/typescript-go /tmp/typescript-go
-//   - npm install oxc-parser  (optional — npm column skipped if missing)
-//
-// Corpus: valid snippets from test/portable-targets.ts, repeated to ~100 / 500 / 2000 KB.
-import { mkdirSync, readFileSync, rmSync, writeFileSync, copyFileSync, existsSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const REPO = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const TMP = '/tmp/portable-bench';
-const TSGO_REPO = process.env.TSGO_REPO ?? '/tmp/typescript-go';
-const OXC_BENCH = resolve(REPO, 'test/oxc-parse-bench');
-const OXC_BIN = resolve(OXC_BENCH, 'target/release/oxc-parse-bench');
-
-const TS_SNIPPETS = [
-  'const a: number = 1;', 'let s: string;', 'type Alias = { a: number; b?: string };',
-  'type U = "a" | "b" | "c";', 'function gen2<T, U extends T>(x: T, y: U): T { return x; }',
-  'interface I<T> extends A<T> { m(x: T): T; }', 'const c = x as const;',
-  'function isStr(x: unknown): x is string { return true; }', 'enum E { A, B, C }',
-  'const n = maybe!;', 'let arr: number[];', 'type Fn = (x: number) => string;',
-  'class C<in out T> { value!: T; }',
-];
-const JS_SNIPPETS = [
-  'var x = 1, y = 2;', 'function f(a, b) { return a + b; }', 'const g = (x) => x * 2;',
-  'x => x + 1;', 'a ? b : c;', 'a.b.c();', 'f(g(1, 2), 3);', '[1, 2, 3].map(f);',
-  'for (let i = 0; i < n; i++) x();', 'for (const k in obj) { y(); }', 'while (x) { z(); }',
-  'if (a) b(); else c();', 'class C extends B { m() {} get p() { return 1; } }', 'a++; b--;',
-  'typeof x; void 0;', 'new Foo(1, 2); new.target;', 'a ?? b; a?.b?.c;',
-  'try { f(); } catch (e) { g(); } finally { h(); }', 'switch (x) { case 1: f(); break; default: g(); }',
-  'a instanceof B; a in obj;', '(function () {})(); (() => {})();', 'x = a && b || c;',
-  'do { x(); } while (y);', 'function* gen() { yield* o(); }', 'const { a, b: c, ...r } = o;',
-  'const [p, , q, ...z] = arr;', 'label: for (;;) { break label; }', 'async function h() { await x; }',
-  'var re = /abc/g; x / y;', 'const t = `a${b}c`;',
-];
-
-function synth(name, snippets, targetKb) {
-  const unit = snippets.join('\n') + '\n';
-  const code = unit.repeat(Math.max(1, Math.ceil((targetKb * 1024) / unit.length)));
-  return { name, code };
-}
-
-const CORPUS_TS = [100, 500, 2000].map((kb) => synth(`typescript-valid-${kb}kb`, TS_SNIPPETS, kb));
-const CORPUS_JS = [100, 500, 2000].map((kb) => synth(`javascript-valid-${kb}kb`, JS_SNIPPETS, kb));
-
-const { emitParser, tsTarget, goTarget, rustTarget } = await import(REPO + '/src/emit.ts');
-const ts = (await import(REPO + '/node_modules/typescript/lib/typescript.js')).default;
-
-let parseSync = null;
-try {
-  ({ parseSync } = await import('oxc-parser'));
-} catch {
-  console.log('oxc-parser npm package not installed — npm column will be skipped');
-}
-
-function time(fn, code, n) {
-  const s = process.hrtime.bigint();
-  for (let i = 0; i < n; i++) fn(code);
-  return Number(process.hrtime.bigint() - s) / 1e6 / n;
-}
-
-function benchPair(label, rows, parseA, parseB, nameA, nameB) {
-  console.log(`\n── ${label} ──`);
-  console.log(`doc                              KB   ${nameA.padStart(10)}   ${nameB.padStart(10)}     ${nameA}/${nameB}`);
-  console.log('-'.repeat(72));
-  let ta = 0, tb = 0;
-  for (const { name, code } of rows) {
-    const iters = code.length > 1e6 ? 3 : code.length > 300_000 ? 10 : 20;
-    for (let i = 0; i < 10 && i * code.length < 2e7; i++) { parseA(code); parseB(code); }
-    let a = Infinity, b = Infinity;
-    for (let r = 0; r < 5; r++) {
-      a = Math.min(a, time(parseA, code, iters));
-      b = Math.min(b, time(parseB, code, iters));
-    }
-    ta += a; tb += b;
-    console.log(`${name.padEnd(30)}${(code.length / 1024).toFixed(0).padStart(5)}   ${a.toFixed(2).padStart(10)}   ${b.toFixed(2).padStart(10)}     ${(a / b).toFixed(2).padStart(6)}x`);
-  }
-  console.log('-'.repeat(72));
-  console.log(`${'AGGREGATE'.padEnd(30)}        ${ta.toFixed(2).padStart(10)}   ${tb.toFixed(2).padStart(10)}     ${(ta / tb).toFixed(2).padStart(6)}x`);
-}
-
-function benchNative(bin, code, iters) {
-  return Number(execFileSync(bin, [String(iters)], { input: code, stdio: ['pipe', 'pipe', 'pipe'] }).toString().trim());
-}
-
-function benchNativeRows(label, rows, monoBin, peerBin, nameA, nameB) {
-  console.log(`\n── ${label} ──`);
-  console.log(`doc                              KB   ${nameA.padStart(10)}   ${nameB.padStart(10)}     ${nameA}/${nameB}`);
-  console.log('-'.repeat(72));
-  let ta = 0, tb = 0;
-  for (const { name, code } of rows) {
-    const iters = code.length > 1e6 ? 5 : code.length > 300_000 ? 15 : 30;
-    for (let i = 0; i < 3; i++) { benchNative(monoBin, code, iters); benchNative(peerBin, code, iters); }
-    let a = Infinity, b = Infinity;
-    for (let r = 0; r < 5; r++) {
-      a = Math.min(a, benchNative(monoBin, code, iters));
-      b = Math.min(b, benchNative(peerBin, code, iters));
-    }
-    ta += a; tb += b;
-    console.log(`${name.padEnd(30)}${(code.length / 1024).toFixed(0).padStart(5)}   ${a.toFixed(2).padStart(10)}   ${b.toFixed(2).padStart(10)}     ${(a / b).toFixed(2).padStart(6)}x`);
-  }
-  console.log('-'.repeat(72));
-  console.log(`${'AGGREGATE'.padEnd(30)}        ${ta.toFixed(2).padStart(10)}   ${tb.toFixed(2).padStart(10)}     ${(ta / tb).toFixed(2).padStart(6)}x`);
-}
-
-function benchRustOxcRows(label, rows, monoBin, oxcNativeBin) {
-  const hasNpm = parseSync !== null;
-  console.log(`\n── ${label} ──`);
-  console.log(
-    'doc                              KB     mono ms   oxc-rs ms' +
-    (hasNpm ? '  oxc-npm ms   mono/oxc-rs  mono/oxc-npm' : '   mono/oxc-rs'),
-  );
-  console.log('-'.repeat(hasNpm ? 88 : 72));
-  let ta = 0, trs = 0, tnpm = 0;
-  const oxcNpm = hasNpm ? (code) => parseSync('bench.js', code) : null;
-  for (const { name, code } of rows) {
-    const iters = code.length > 1e6 ? 5 : code.length > 300_000 ? 15 : 30;
-    for (let i = 0; i < 3; i++) {
-      benchNative(monoBin, code, iters);
-      benchNative(oxcNativeBin, code, iters);
-      if (hasNpm) oxcNpm(code);
-    }
-    let a = Infinity, rs = Infinity, npm = Infinity;
-    for (let r = 0; r < 5; r++) {
-      a = Math.min(a, benchNative(monoBin, code, iters));
-      rs = Math.min(rs, benchNative(oxcNativeBin, code, iters));
-      if (hasNpm) npm = Math.min(npm, time(oxcNpm, code, iters));
-    }
-    ta += a; trs += rs; if (hasNpm) tnpm += npm;
-    const kb = (code.length / 1024).toFixed(0).padStart(5);
-    if (hasNpm) {
-      console.log(
-        `${name.padEnd(30)}${kb}   ${a.toFixed(2).padStart(10)}   ${rs.toFixed(2).padStart(10)}   ${npm.toFixed(2).padStart(10)}     ${(a / rs).toFixed(2).padStart(6)}x      ${(a / npm).toFixed(2).padStart(6)}x`,
-      );
-    } else {
-      console.log(`${name.padEnd(30)}${kb}   ${a.toFixed(2).padStart(10)}   ${rs.toFixed(2).padStart(10)}     ${(a / rs).toFixed(2).padStart(6)}x`);
-    }
-  }
-  console.log('-'.repeat(hasNpm ? 88 : 72));
-  if (hasNpm) {
-    console.log(
-      `${'AGGREGATE'.padEnd(30)}        ${ta.toFixed(2).padStart(10)}   ${trs.toFixed(2).padStart(10)}   ${tnpm.toFixed(2).padStart(10)}     ${(ta / trs).toFixed(2).padStart(6)}x      ${(ta / tnpm).toFixed(2).padStart(6)}x`,
-    );
-  } else {
-    console.log(`${'AGGREGATE'.padEnd(30)}        ${ta.toFixed(2).padStart(10)}   ${trs.toFixed(2).padStart(10)}     ${(ta / trs).toFixed(2).padStart(6)}x`);
-  }
-}
-
-function buildTsgoBench() {
-  if (!existsSync(TSGO_REPO)) {
-    throw new Error(`typescript-go not found at ${TSGO_REPO} — git clone --depth 1 https://github.com/microsoft/typescript-go ${TSGO_REPO}`);
-  }
-  const cmdDir = resolve(TSGO_REPO, 'cmd/parsebench');
-  mkdirSync(cmdDir, { recursive: true });
-  copyFileSync(resolve(REPO, 'test/tsgo-parsebench/main.go'), resolve(cmdDir, 'main.go'));
-  const out = `${TMP}/tsgobench/p`;
-  mkdirSync(`${TMP}/tsgobench`, { recursive: true });
-  execFileSync('go', ['build', '-o', out, './cmd/parsebench'], { cwd: TSGO_REPO, stdio: 'pipe' });
-  return out;
-}
-
-function buildOxcNativeBench() {
-  execFileSync('cargo', ['build', '--release', '--manifest-path', resolve(OXC_BENCH, 'Cargo.toml')], { stdio: 'pipe' });
-  if (!existsSync(OXC_BIN)) throw new Error(`oxc bench binary missing after build: ${OXC_BIN}`);
-  return OXC_BIN;
-}
-
-// ── tsTarget vs tsc ──
-rmSync(`${TMP}/ts`, { recursive: true, force: true });
-mkdirSync(`${TMP}/ts`, { recursive: true });
-const tsGrammar = (await import(REPO + '/typescript.ts')).default;
-writeFileSync(`${TMP}/ts/p.mts`, emitParser(tsGrammar, tsTarget));
-const monoTs = await import(`${TMP}/ts/p.mts?v=${Date.now()}`);
-const monoTsParse = (code) => {
-  const root = monoTs.parse(monoTs.tokenize(code));
-  if (root === null) throw new Error('parse failed');
-};
-const tscParse = (code) => ts.createSourceFile('f.ts', code, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-benchPair('tsTarget (typescript.ts) vs tsc createSourceFile', CORPUS_TS, monoTsParse, tscParse, 'mono ms', 'tsc ms');
-
-// ── goTarget vs typescript-go parser ──
-rmSync(`${TMP}/go`, { recursive: true, force: true });
-mkdirSync(`${TMP}/go`, { recursive: true });
-const jsGrammar = (await import(REPO + '/javascript.ts')).default;
-writeFileSync(`${TMP}/go/parser.go`, emitParser(jsGrammar, goTarget));
-writeFileSync(`${TMP}/go/runner.go`, goTarget.emitRunner());
-writeFileSync(`${TMP}/go/go.mod`, 'module bench\n\ngo 1.21\n');
-execFileSync('go', ['build', '-o', `${TMP}/go/p`, '.'], { cwd: `${TMP}/go`, stdio: 'pipe' });
-
-const tsgoBin = buildTsgoBench();
-benchNativeRows(
-  'goTarget (javascript.ts) vs typescript-go ParseSourceFile',
-  CORPUS_JS, `${TMP}/go/p`, tsgoBin, 'mono ms', 'tsgo ms',
-);
-
-// ── rustTarget vs oxc (native + npm) ──
-rmSync(`${TMP}/rust`, { recursive: true, force: true });
-mkdirSync(`${TMP}/rust`, { recursive: true });
-writeFileSync(`${TMP}/rust/main.rs`, emitParser(jsGrammar, rustTarget) + rustTarget.emitRunner());
-execFileSync('rustc', ['-O', '-A', 'warnings', `${TMP}/rust/main.rs`, '-o', `${TMP}/rust/p`], { stdio: 'pipe' });
-
-const oxcNativeBin = buildOxcNativeBench();
-benchRustOxcRows(
-  'rustTarget (javascript.ts) vs oxc native + oxc npm',
-  CORPUS_JS, `${TMP}/rust/p`, oxcNativeBin,
-);
-
-console.log('\nNote: Monogram builds a full CST; oxc/tsc/tsgo build AST/SourceFile.');
-console.log('oxc-rs: test/oxc-parse-bench (oxc_parser crate, arena reset per iter).');
-console.log('oxc-npm: oxc-parser parseSync (includes NAPI + JS AST materialization).');
-console.log('Corpus: portable-targets gate snippets repeated to size.');
diff --git a/test/profile-vs-peers.mjs b/test/profile-vs-peers.mjs
deleted file mode 100644
index 801ecde..0000000
--- a/test/profile-vs-peers.mjs
+++ /dev/null
@@ -1,102 +0,0 @@
-// Benchmark the EMITTED Monogram parsers against the reference parser of each
-// ecosystem, same methodology as profile-vs-tsc.mjs (warmup ×10, min of 5 rounds):
-//   - javascript.ts vs acorn (the ESTree reference implementation), on real-world
-//     JS from node_modules — including acorn parsing itself and the 8.7MB
-//     typescript.js bundle.
-//   - html.ts vs parse5 (the WHATWG reference implementation), on synthesized
-//     well-formed documents (Monogram's HTML grammar is the well-formed subset,
-//     so the corpus is generated from a representative block — disclosed as such).
-// Output shapes differ by design — Monogram builds a full CST (every token a
-// leaf), acorn an ESTree AST, parse5 a DOM-shaped tree — so this is parse-to-tree
-// wall time on identical inputs, not equal-work accounting.
-//   node test/profile-vs-peers.mjs
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const REPO = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const acorn = await import(REPO + '/node_modules/acorn/dist/acorn.mjs');
-const parse5 = await import(REPO + '/node_modules/parse5/dist/index.js');
-const { emitParser, jsTarget } = await import(REPO + '/src/emit.ts');
-
-writeFileSync('/tmp/emitted-peers-js.mts', emitParser((await import(REPO + '/javascript.ts')).default, jsTarget));
-writeFileSync('/tmp/emitted-peers-html.mts', emitParser((await import(REPO + '/html.ts')).default, jsTarget));
-const monoJs = await import('/tmp/emitted-peers-js.mts?v=' + Date.now());
-const monoHtml = await import('/tmp/emitted-peers-html.mts?v=' + Date.now());
-
-function time(fn, code, name, n) {
-  const s = process.hrtime.bigint();
-  for (let i = 0; i < n; i++) fn(code, name);
-  return Number(process.hrtime.bigint() - s) / 1e6 / n;
-}
-function bench(rows, parseA, parseB) {
-  let ta = 0, tb = 0;
-  for (const { name, code } of rows) {
-    const iters = code.length > 1e6 ? 3 : 20;
-    for (let i = 0; i < 10 && i * code.length < 2e7; i++) { parseA(code, name); parseB(code, name); }
-    let a = Infinity, b = Infinity;
-    for (let r = 0; r < 5; r++) {
-      a = Math.min(a, time(parseA, code, name, iters));
-      b = Math.min(b, time(parseB, code, name, iters));
-    }
-    ta += a; tb += b;
-    console.log(`${name.padEnd(30)}${(code.length / 1024).toFixed(0).padStart(5)}   ${a.toFixed(2).padStart(8)}   ${b.toFixed(2).padStart(8)}     ${(a / b).toFixed(2).padStart(6)}x`);
-  }
-  console.log('-'.repeat(72));
-  console.log(`${'AGGREGATE'.padEnd(30)}        ${ta.toFixed(2).padStart(8)}   ${tb.toFixed(2).padStart(8)}     ${(ta / tb).toFixed(2).padStart(6)}x`);
-}
-
-// ── JavaScript vs acorn ──
-const jsFiles = [
-  'node_modules/acorn/dist/acorn.js',
-  'node_modules/parse5/dist/parser/index.js',
-  'node_modules/typescript/lib/typescript.js',
-].map((p) => ({ name: p.split('/').pop(), code: readFileSync(resolve(REPO, p), 'utf-8') }));
-
-// acorn needs the right sourceType per file (ESM dist files vs scripts) — detect once.
-const sourceType = new Map(jsFiles.map(({ name, code }) => {
-  try { acorn.parse(code, { ecmaVersion: 'latest' }); return [name, 'script']; }
-  catch { return [name, 'module']; }
-}));
-const acornParse = (code, name) => acorn.parse(code, { ecmaVersion: 'latest', sourceType: sourceType.get(name) });
-
-console.log('── JavaScript: emitted javascript.ts vs acorn (ESTree reference) ──');
-console.log('file                             KB    mono ms   acorn ms   mono/acorn');
-console.log('-'.repeat(72));
-bench(jsFiles, (c) => monoJs.parse(c), (c, name) => acornParse(c, name));
-
-// ── HTML vs parse5 ──
-const block = `
-<section class="card" data-id="42">
-  <h2 id="t42">Title &amp; subtitle</h2>
-  <p>Some <em>emphasized</em> and <strong>bold</strong> text with an <a href="/x?a=1&amp;b=2">anchor</a>.</p>
-  <ul>
-    <li>alpha</li>
-    <li>beta <span class="tag">x</span></li>
-  </ul>
-  <table>
-    <tr><th>k</th><th>v</th></tr>
-    <tr><td>1</td><td>one</td></tr>
-  </table>
-  <!-- block comment -->
-  <img src="/img.png" alt="pic"/>
-  <input type="text" value="v" disabled/>
-</section>`;
-// Fragment-level on both sides (Monogram's HTML grammar is the well-formed
-// FRAGMENT subset — no doctype/html scaffolding), so parse5 gets parseFragment.
-const doc = (n) => `<div id="root">
-  <style>.card { color: #333; } .tag::after { content: "*"; }</style>
-  <script>function f(a, b) { return a < b ? a : b; }</script>${block.repeat(n)}
-</div>`;
-const htmlDocs = [50, 200, 800].map((kb) => {
-  const n = Math.round((kb * 1024) / block.length);
-  const code = doc(n);
-  return { name: `synthetic-${(code.length / 1024).toFixed(0)}kb.html`, code };
-});
-
-console.log('\n── HTML: emitted html.ts vs parse5 (WHATWG reference) ──');
-console.log('doc                              KB    mono ms  parse5 ms   mono/parse5');
-console.log('-'.repeat(72));
-// Sanity: both sides must actually parse the synthetic corpus.
-for (const { name, code } of htmlDocs) { monoHtml.parse(code); parse5.parseFragment(code); }
-bench(htmlDocs, (c) => monoHtml.parse(c), (c) => parse5.parseFragment(c));
diff --git a/test/profile-vs-tsc.mjs b/test/profile-vs-tsc.mjs
deleted file mode 100644
index 61d7382..0000000
--- a/test/profile-vs-tsc.mjs
+++ /dev/null
@@ -1,115 +0,0 @@
-// CPU-profile the EMITTED Monogram parser vs the official tsc parser on the PR#4 bench
-// files: per-file timing ratio, then a V8 profile of each engine with top self-time
-// tables + layer shares (lexer / parser / GC).
-//   node test/profile-vs-tsc.mjs                 # timing table + both profiles
-//   node --no-turbo-inlining test/profile-vs-tsc.mjs   # honest per-fn attribution
-// Writes /tmp/mono.cpuprofile + /tmp/tsc.cpuprofile (inspect via test/profile-lines.mjs).
-import { Session } from 'node:inspector';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const REPO = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const ts = (await import(REPO + '/node_modules/typescript/lib/typescript.js')).default;
-const { emitParser, jsTarget } = await import(REPO + '/src/emit.ts');
-const grammar = (await import(REPO + '/typescript.ts')).default;
-
-writeFileSync('/tmp/emitted-current.mts', emitParser(grammar, jsTarget));
-const emitted = await import('/tmp/emitted-current.mts?v=' + Date.now());
-
-const paths = [
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserharness.ts',
-  '/tmp/ts-repo/tests/cases/conformance/fixSignatureCaching.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/parserRealSource7.ts',
-  '/tmp/ts-repo/tests/cases/conformance/parser/ecmascript5/RealWorld/parserindenter.ts',
-];
-const files = paths.map((p) => ({ name: p.split('/').pop(), code: readFileSync(p, 'utf-8') }));
-
-const mono = (code) => emitted.parse(code);
-const tscF = (code) => ts.createSourceFile('f.ts', code, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-const tscT = (code) => ts.createSourceFile('f.ts', code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-function time(fn, code, n) {
-  const s = process.hrtime.bigint();
-  for (let i = 0; i < n; i++) { try { fn(code); } catch {} }
-  return Number(process.hrtime.bigint() - s) / 1e6 / n;
-}
-
-for (const { code } of files) for (let i = 0; i < 10; i++) { try { mono(code); tscF(code); tscT(code); } catch {} }
-console.log('file                          KB    mono ms   tsc(f) ms  tsc(t) ms   mono/tsc(f)  mono/tsc(t)');
-console.log('-'.repeat(100));
-let tm = 0, tf = 0, tt = 0;
-for (const { name, code } of files) {
-  let m = Infinity, f = Infinity, t = Infinity;
-  for (let r = 0; r < 5; r++) {
-    m = Math.min(m, time(mono, code, 20));
-    f = Math.min(f, time(tscF, code, 20));
-    t = Math.min(t, time(tscT, code, 20));
-  }
-  tm += m; tf += f; tt += t;
-  console.log(`${name.padEnd(28)}${(code.length / 1024).toFixed(0).padStart(4)}   ${m.toFixed(2).padStart(7)}   ${f.toFixed(2).padStart(8)}   ${t.toFixed(2).padStart(8)}     ${(m / f).toFixed(2).padStart(6)}x      ${(m / t).toFixed(2).padStart(5)}x`);
-}
-console.log('-'.repeat(100));
-console.log(`${'AGGREGATE'.padEnd(28)}       ${tm.toFixed(2).padStart(7)}   ${tf.toFixed(2).padStart(8)}   ${tt.toFixed(2).padStart(8)}     ${(tm / tf).toFixed(2).padStart(6)}x      ${(tm / tt).toFixed(2).padStart(5)}x`);
-
-const session = new Session();
-session.connect();
-const post = (method, params) => new Promise((res, rej) => session.post(method, params, (e, r) => (e ? rej(e) : res(r))));
-await post('Profiler.enable');
-await post('Profiler.setSamplingInterval', { interval: 100 });
-
-async function profileEngine(fn, seconds) {
-  for (const { code } of files) for (let i = 0; i < 5; i++) { try { fn(code); } catch {} }
-  await post('Profiler.start');
-  const s = process.hrtime.bigint();
-  let rounds = 0;
-  while (Number(process.hrtime.bigint() - s) / 1e9 < seconds) {
-    for (const { code } of files) { try { fn(code); } catch {} }
-    rounds++;
-  }
-  const { profile } = await post('Profiler.stop');
-  return { profile, rounds };
-}
-
-function analyze(tag, profile, lexerRoots) {
-  const byId = new Map(profile.nodes.map((n) => [n.id, n]));
-  const childOf = new Map();
-  for (const n of profile.nodes) for (const c of n.children ?? []) childOf.set(c, n.id);
-  const isLexerRoot = (n) => lexerRoots.test(n.callFrame.functionName || '');
-  const lexerFlag = new Map();
-  const flagOf = (id) => {
-    if (lexerFlag.has(id)) return lexerFlag.get(id);
-    const n = byId.get(id);
-    const v = isLexerRoot(n) || (childOf.has(id) ? flagOf(childOf.get(id)) : false);
-    lexerFlag.set(id, v);
-    return v;
-  };
-  let total = 0, gc = 0, lexer = 0, idle = 0;
-  const byFn = new Map();
-  for (const n of profile.nodes) {
-    const hc = n.hitCount || 0;
-    if (!hc) continue;
-    const fn = n.callFrame.functionName || '(anonymous)';
-    if (fn === '(idle)' || fn === '(program)') { idle += hc; continue; }
-    total += hc;
-    if (fn === '(garbage collector)') { gc += hc; continue; }
-    if (flagOf(n.id)) lexer += hc;
-    const file = (n.callFrame.url || '').split('/').pop() || '(native)';
-    byFn.set(`${fn}  @${file}:${n.callFrame.lineNumber + 1}`, (byFn.get(`${fn}  @${file}:${n.callFrame.lineNumber + 1}`) || 0) + hc);
-  }
-  const parser = total - gc - lexer;
-  console.log(`\n══ ${tag} ══  ${total} samples (idle/program excluded: ${idle})`);
-  console.log(`  layers: lexer ${(100 * lexer / total).toFixed(1)}%   parser ${(100 * parser / total).toFixed(1)}%   GC ${(100 * gc / total).toFixed(1)}%`);
-  console.log('  self%  samples  function');
-  for (const [k, v] of [...byFn.entries()].sort((a, b) => b[1] - a[1]).slice(0, 25))
-    console.log(`  ${(100 * v / total).toFixed(1).padStart(5)}  ${String(v).padStart(7)}  ${k}`);
-}
-
-const pm = await profileEngine(mono, 4);
-const pf = await profileEngine(tscF, 4);
-writeFileSync('/tmp/mono.cpuprofile', JSON.stringify(pm.profile));
-writeFileSync('/tmp/tsc.cpuprofile', JSON.stringify(pf.profile));
-
-analyze(`Monogram emitted (${pm.rounds} rounds)`, pm.profile, /^tokenize$/);
-analyze(`tsc setParentNodes=false (${pf.rounds} rounds)`, pf.profile, /^(scan|reScan\w+)$/);
-console.log('\nwrote /tmp/mono.cpuprofile /tmp/tsc.cpuprofile');
diff --git a/test/sanity-check.ts b/test/sanity-check.ts
deleted file mode 100644
index c3aee4f..0000000
--- a/test/sanity-check.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { createParser } from '../src/gen-parser.ts';
-
-const grammar = (await import('../typescript.ts')).default;
-const { parse } = createParser(grammar);
-
-// Sanity checks for common syntax
-const tests = [
-  'var x = 1;',
-  'function foo() {}',
-  'class C { x: number = 1; m() { return this.x; } }',
-  'type Foo<T> = T extends string ? T : never;',
-  'interface I { x: number; m(): void; }',
-  'async function* gen() { yield 1; yield* other(); }',
-  'const c = { x: 1, m() {}, get a() { return 1; } };',
-  '() => 1',
-  'a?.b?.[c]?.()',
-  '`hello ${name}`',
-  `type T = \`\${infer U}\`;`,
-  '@dec class C { @prop x: number; m(@d arg: T) {} }',
-  'import { a, b as c } from "m";',
-  'export default function() {}',
-  'export type { T } from "m";',
-];
-
-let passed = 0;
-for (const code of tests) {
-  try {
-    parse(code);
-    passed++;
-  } catch (e: any) {
-    console.log(`FAIL: ${code}`);
-    console.log(`  ${e.message.slice(0, 100)}`);
-  }
-}
-console.log(`${passed}/${tests.length} basic tests pass`);
-process.exit(passed === tests.length ? 0 : 1);
diff --git a/test/snapshot.ts b/test/snapshot.ts
deleted file mode 100644
index 5c2754f..0000000
--- a/test/snapshot.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-// Snapshot/diff harness: tracks exactly which files pass, so grammar changes
-// can be evaluated for regressions (pass->fail) as well as wins (fail->pass).
-import { createParser } from '../src/gen-parser.ts';
-import { readdir, writeFile, readFile } from 'fs/promises';
-import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
-
-const grammar = (await import('../typescript.ts')).default;
-const { parse } = createParser(grammar);
-const baseDir = '/tmp/ts-repo/tests/cases/conformance';
-const SNAP = '/tmp/pass-snapshot.json';
-
-async function getAllTsFiles(dir: string): Promise<string[]> {
-  const files: string[] = [];
-  for (const entry of await readdir(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) files.push(...await getAllTsFiles(full));
-    else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) files.push(full);
-  }
-  return files;
-}
-
-const files = (await getAllTsFiles(baseDir)).sort();
-const passing = new Set<string>();
-for (const file of files) {
-  const code = readFileSync(file, 'utf-8');
-  try { parse(code); passing.add(file.replace(baseDir + '/', '')); } catch {}
-}
-
-console.log(`${passing.size}/${files.length} passed (${(passing.size / files.length * 100).toFixed(1)}%)`);
-
-const mode = process.argv[2];
-if (mode === 'save') {
-  await writeFile(SNAP, JSON.stringify([...passing].sort(), null, 0));
-  console.log(`Saved baseline snapshot (${passing.size} passing) to ${SNAP}`);
-} else {
-  if (!existsSync(SNAP)) { console.log('No baseline snapshot. Run with "save" first.'); process.exit(0); }
-  const base = new Set<string>(JSON.parse(await readFile(SNAP, 'utf-8')));
-  const regressions = [...base].filter(f => !passing.has(f)).sort();
-  const wins = [...passing].filter(f => !base.has(f)).sort();
-  console.log(`\nBaseline: ${base.size} passing`);
-  console.log(`Net delta: ${passing.size - base.size >= 0 ? '+' : ''}${passing.size - base.size}`);
-  console.log(`\nREGRESSIONS (pass->fail): ${regressions.length}`);
-  for (const f of regressions) console.log(`  - ${f}`);
-  console.log(`\nWINS (fail->pass): ${wins.length}`);
-  for (const f of wins) console.log(`  + ${f}`);
-}
diff --git a/test/token-dfa-verify.ts b/test/token-dfa-verify.ts
deleted file mode 100644
index a86f6c8..0000000
--- a/test/token-dfa-verify.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-// Correctness + speed gate for token-dfa.ts: for every TS token whose pattern compiles
-// to a DFA, the DFA's match length must equal the token's sticky-regex match length at
-// EVERY position of the corpus (byte-identical), and we measure the per-token speedup.
-//
-//   node test/token-dfa-verify.ts
-import { compileTokenDfa } from '../src/token-dfa.ts';
-import { tokenPatternSource } from '../src/token-pattern.ts';
-import { readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-
-const grammar = (await import('../typescript.ts')).default;
-
-const base = '/tmp/ts-repo/tests/cases/conformance';
-function walk(d: string): string[] {
-  const o: string[] = [];
-  for (const e of readdirSync(d, { withFileTypes: true })) {
-    const f = join(d, e.name);
-    if (e.isDirectory()) o.push(...walk(f));
-    else if (e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) o.push(f);
-  }
-  return o;
-}
-const files = walk(base).sort().filter((_, i) => i % 11 === 0);   // ~stride sample
-const sources = files.map(f => { try { return readFileSync(f, 'utf-8'); } catch { return ''; } }).filter(Boolean);
-const totalChars = sources.reduce((a, s) => a + s.length, 0);
-
-// Tokens the per-position lexer loop actually runs through a regex (skip template).
-const tokens = grammar.tokens.filter(t => !t.template);
-
-console.log(`tokens: ${tokens.length} · corpus sample: ${sources.length} files, ${(totalChars / 1024).toFixed(0)} KB\n`);
-console.log('token            DFA?    positions   mism   regex ms   dfa ms   speedup');
-console.log('-'.repeat(78));
-
-let totalMism = 0, compiled = 0, fellBack = 0;
-for (const t of tokens) {
-  let src: string;
-  try { src = tokenPatternSource(t); } catch { src = ''; }
-  const dfa = compileTokenDfa(t.pattern);
-  if (!dfa) {
-    fellBack++;
-    console.log(`${t.name.padEnd(16)} regex   ${'—'.padStart(10)}   ${'—'.padStart(4)}   (unsupported → falls back to regex)`);
-    continue;
-  }
-  compiled++;
-  const re = new RegExp(`(?:${src})`, 'y');
-
-  // Correctness: at every position, DFA length === regex length.
-  let mism = 0, positions = 0;
-  for (const s of sources) {
-    for (let pos = 0; pos < s.length; pos++) {
-      re.lastIndex = pos;
-      const m = re.exec(s);
-      const reLen = m ? m[0].length : -1;
-      const dfaLen = dfa.match(s, pos);
-      positions++;
-      if (reLen !== dfaLen) {
-        if (mism < 3) console.log(`    MISMATCH @${pos} re=${reLen} dfa=${dfaLen} ctx=${JSON.stringify(s.slice(pos, pos + 24))}`);
-        mism++;
-      }
-    }
-  }
-  totalMism += mism;
-
-  // Speed: scan each source once via regex vs DFA (best-of-5).
-  const timeRe = () => { let acc = 0; for (const s of sources) for (let p = 0; p < s.length; p++) { re.lastIndex = p; const m = re.exec(s); acc += m ? m[0].length : 0; } return acc; };
-  const timeDfa = () => { let acc = 0; for (const s of sources) for (let p = 0; p < s.length; p++) { const l = dfa.match(s, p); acc += l > 0 ? l : 0; } return acc; };
-  const best = (fn: () => number) => { for (let w = 0; w < 2; w++) fn(); let b = Infinity; for (let r = 0; r < 5; r++) { const t0 = process.hrtime.bigint(); fn(); const dt = Number(process.hrtime.bigint() - t0) / 1e6; if (dt < b) b = dt; } return b; };
-  const reMs = best(timeRe), dfaMs = best(timeDfa);
-  console.log(`${t.name.padEnd(16)} dfa     ${String(positions).padStart(10)}   ${String(mism).padStart(4)}   ${reMs.toFixed(1).padStart(8)}   ${dfaMs.toFixed(1).padStart(6)}   ${(reMs / dfaMs).toFixed(2)}×`);
-}
-
-console.log('-'.repeat(78));
-console.log(`compiled to DFA: ${compiled} · fell back to regex: ${fellBack} · TOTAL mismatches: ${totalMism}`);
-process.exit(totalMism === 0 ? 0 : 1);
diff --git a/test/treesitter-smoke.ts b/test/treesitter-smoke.ts
deleted file mode 100644
index bba77ff..0000000
--- a/test/treesitter-smoke.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-// Smoke test for gen-treesitter: generate a tree-sitter package from the
-// TypeScript grammar and structurally sanity-check the three artifacts
-// (grammar.js, queries/highlights.scm, src/scanner.c).
-//
-// Run with: node test/treesitter-smoke.ts
-//
-// If the `tree-sitter` CLI is installed, this ALSO tries to compile the generated
-// grammar.js and reports the result — but never fails the suite on a missing
-// toolchain (the task says: validate structurally, don't block on installs).
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import vm from 'node:vm';
-import { generateTreeSitter } from '../src/gen-treesitter.ts';
-
-const grammar = (await import('../typescript.ts')).default;
-const yamlGrammar = (await import('../yaml.ts')).default;
-
-let ok = 0, fail = 0;
-const check = (label: string, cond: boolean) => {
-  if (cond) ok++;
-  else { fail++; console.log('  ✗', label); }
-};
-
-const { grammarJs, highlightsScm, scannerC, externalTokens } = generateTreeSitter(grammar, 'typescript');
-
-// ── grammar.js ──────────────────────────────────────────────────────────────
-check('grammar.js is non-empty', grammarJs.length > 500);
-check('grammar.js calls grammar({...})', /module\.exports\s*=\s*grammar\(\{/.test(grammarJs));
-check('grammar.js has a name field', /name:\s*"typescript"/.test(grammarJs));
-check('grammar.js has a rules: block', /rules:\s*\{/.test(grammarJs));
-check('grammar.js declares extras (whitespace + comments)', /extras:\s*\$ =>/.test(grammarJs));
-check('grammar.js declares word (identifier token)', /word:\s*\$ =>\s*\$\.\w+/.test(grammarJs));
-check('grammar.js references the entry rule (program)', /\bprogram:\s*\$ =>/.test(grammarJs));
-check('grammar.js uses seq()', grammarJs.includes('seq('));
-check('grammar.js uses choice()', grammarJs.includes('choice('));
-check('grammar.js uses optional()', grammarJs.includes('optional('));
-check('grammar.js uses repeat()', grammarJs.includes('repeat('));
-check('grammar.js maps prec.left for left-assoc operators', grammarJs.includes('prec.left('));
-check('grammar.js maps prec.right for right-assoc operators', grammarJs.includes('prec.right('));
-check('grammar.js declares conflicts (generics/arrow ambiguities)', /conflicts:\s*\$ =>/.test(grammarJs));
-check('grammar.js declares externals (scanner regex token)', /externals:\s*\$ =>/.test(grammarJs));
-check('grammar.js maps operator into a field', grammarJs.includes("field('operator'"));
-check('grammar.js wraps declaration names in a name field', grammarJs.includes("field('name'"));
-
-// Balanced parens/braces — a crude validity check on the generated JS.
-function balanced(src: string, open: string, close: string): boolean {
-  let depth = 0, inStr: string | null = null, inRegex = false, prev = '';
-  for (let i = 0; i < src.length; i++) {
-    const c = src[i];
-    if (inStr) { if (c === inStr && prev !== '\\') inStr = null; prev = c; continue; }
-    if (inRegex) { if (c === '/' && prev !== '\\') inRegex = false; prev = c; continue; }
-    if (c === '"' || c === "'") { inStr = c; prev = c; continue; }
-    // crude regex-literal skip: `/` preceded by `(` or `,` or whitespace
-    if (c === '/' && /[(,\s]/.test(prev)) { inRegex = true; prev = c; continue; }
-    if (c === open) depth++;
-    else if (c === close) { depth--; if (depth < 0) return false; }
-    prev = c;
-  }
-  return depth === 0;
-}
-check('grammar.js has balanced parentheses', balanced(grammarJs, '(', ')'));
-check('grammar.js has balanced braces', balanced(grammarJs, '{', '}'));
-
-// Strongest validity check: the generated grammar.js must PARSE and EXECUTE as
-// real JS through stubbed tree-sitter DSL globals. This catches malformed regex
-// literals, stray tokens, and unresolved references that brace-counting misses.
-function grammarExecutes(src: string): { ok: boolean; ruleCount: number; err?: string } {
-  const mk = (name: string) => (...args: unknown[]) => ({ type: name, args });
-  const prec = Object.assign((...a: unknown[]) => mk('prec')(...a), {
-    left: (...a: unknown[]) => mk('prec.left')(...a),
-    right: (...a: unknown[]) => mk('prec.right')(...a),
-  });
-  const sandbox: Record<string, unknown> = {
-    module: { exports: {} as { rules?: Record<string, unknown> } },
-    grammar: (def: any) => {
-      const $ = new Proxy({}, { get: (_t, k) => ({ type: 'ref', name: String(k) }) });
-      for (const fn of Object.values(def.rules)) (fn as (x: unknown) => unknown)($);
-      for (const k of ['extras', 'word', 'externals', 'conflicts']) if (def[k]) def[k]($);
-      return def;
-    },
-    seq: mk('seq'), choice: mk('choice'), optional: mk('optional'),
-    repeat: mk('repeat'), repeat1: mk('repeat1'), token: mk('token'),
-    field: mk('field'), blank: mk('blank'), prec,
-  };
-  vm.createContext(sandbox);
-  try {
-    new vm.Script(src, { filename: 'grammar.js' });
-    vm.runInContext(src, sandbox, { filename: 'grammar.js' });
-    const exp = (sandbox.module as { exports: { rules?: Record<string, unknown> } }).exports;
-    return { ok: true, ruleCount: Object.keys(exp.rules ?? {}).length };
-  } catch (e: any) {
-    return { ok: false, ruleCount: 0, err: e.message };
-  }
-}
-const exec = grammarExecutes(grammarJs);
-check(`grammar.js parses & executes as JS${exec.err ? ' (' + exec.err + ')' : ''}`, exec.ok);
-check(`grammar.js exposes all rules after execution (${exec.ruleCount})`, exec.ruleCount >= grammar.rules.length);
-
-const yamlGrammarJs = generateTreeSitter(yamlGrammar, 'yaml').grammarJs;
-const yamlExec = grammarExecutes(yamlGrammarJs);
-const emptyRegexTokenCall = 'token(/' + '/)';
-check('YAML grammar.js never emits empty regex token call', !yamlGrammarJs.includes(emptyRegexTokenCall));
-check(`YAML grammar.js parses & executes as JS${yamlExec.err ? ' (' + yamlExec.err + ')' : ''}`, yamlExec.ok);
-
-// Every rule and non-scanner token should appear as a rule entry.
-const ruleNamesSnake = grammar.rules.map(r => r.name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase());
-const missingRules = ruleNamesSnake.filter(n => !new RegExp(`\\b${n}:\\s*\\$ =>`).test(grammarJs));
-check(`all ${grammar.rules.length} rules emitted (missing: ${missingRules.join(',') || 'none'})`, missingRules.length === 0);
-
-// ── highlights.scm ────────────────────────────────────────────────────────────
-check('highlights.scm is non-empty', highlightsScm.length > 200);
-check('highlights.scm has @keyword captures', highlightsScm.includes('@keyword'));
-check('highlights.scm has @string captures', highlightsScm.includes('@string'));
-check('highlights.scm has @number captures', highlightsScm.includes('@number'));
-check('highlights.scm has @operator captures', highlightsScm.includes('@operator'));
-check('highlights.scm has @type captures', highlightsScm.includes('@type'));
-check('highlights.scm has @function captures', highlightsScm.includes('@function'));
-check('highlights.scm has @comment captures', highlightsScm.includes('@comment'));
-check('highlights.scm has @variable fallback', highlightsScm.includes('@variable'));
-check('highlights.scm has @constant.builtin (true/false/null)', highlightsScm.includes('@constant.builtin'));
-check('highlights.scm has @type.builtin (primitives)', highlightsScm.includes('@type.builtin'));
-check('highlights.scm captures specific keywords (class)', highlightsScm.includes('"class"'));
-check('highlights.scm uses list form [ … ] for grouped literals', /\[\s*\n/.test(highlightsScm));
-check('highlights.scm queries declaration names via the name: field', /name:\s*\(\w+\)\s*@/.test(highlightsScm));
-check('highlights.scm uses only standard predicates (#any-of?/#eq?/#match?)',
-  (highlightsScm.match(/#[\w-]+\?/g) ?? []).every(p => ['#any-of?', '#eq?', '#match?', '#not-eq?', '#set!'].includes(p)));
-// Balanced brackets in the query file.
-check('highlights.scm has balanced brackets', balanced(highlightsScm, '[', ']'));
-check('highlights.scm has balanced parens', balanced(highlightsScm, '(', ')'));
-
-// Count captures — should be plentiful.
-const captureCount = (highlightsScm.match(/@[\w.]+/g) ?? []).length;
-check(`highlights.scm has many captures (${captureCount})`, captureCount > 30);
-
-// ── scanner.c ─────────────────────────────────────────────────────────────────
-check('scanner.c is non-empty', scannerC.length > 300);
-check('scanner.c includes parser.h', scannerC.includes('#include "tree_sitter/parser.h"'));
-check('scanner.c defines the 5 required entry points',
-  scannerC.includes('_external_scanner_create') &&
-  scannerC.includes('_external_scanner_destroy') &&
-  scannerC.includes('_external_scanner_serialize') &&
-  scannerC.includes('_external_scanner_deserialize') &&
-  scannerC.includes('_external_scanner_scan'));
-check('scanner.c declares a TokenType enum', scannerC.includes('enum TokenType'));
-check('scanner.c implements regex-literal scan', scannerC.includes('scan_regex'));
-check('scanner.c derives regex flag chars from the token', /flags = "[a-z]+"/i.test(scannerC));
-check('scanner.c references the external token name', externalTokens.length > 0 && scannerC.includes(externalTokens[0].toUpperCase()));
-check('scanner.c documents the template stub with derived delimiters', scannerC.includes('interpOpen  = "${"'));
-check('externalTokens reported', externalTokens.length >= 1);
-
-// ── Optional: try the real tree-sitter CLI if present ──────────────────────────
-function hasTreeSitter(): boolean {
-  try { execFileSync('tree-sitter', ['--version'], { stdio: 'ignore' }); return true; }
-  catch { return false; }
-}
-
-if (hasTreeSitter()) {
-  console.log('\ntree-sitter CLI found — attempting to generate the parser…');
-  try {
-    const dir = mkdtempSync(join(tmpdir(), 'monogram-ts-'));
-    mkdirSync(join(dir, 'src'), { recursive: true });
-    mkdirSync(join(dir, 'queries'), { recursive: true });
-    writeFileSync(join(dir, 'grammar.js'), grammarJs);
-    writeFileSync(join(dir, 'queries', 'highlights.scm'), highlightsScm);
-    writeFileSync(join(dir, 'src', 'scanner.c'), scannerC);
-    writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'tree-sitter-typescript-monogram', version: '0.0.0' }, null, 2));
-    try {
-      const result = execFileSync('tree-sitter', ['generate'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
-      console.log('  tree-sitter generate SUCCEEDED');
-      if (result.trim()) console.log('  ' + result.trim().split('\n').join('\n  '));
-    } catch (e: any) {
-      console.log('  tree-sitter generate reported issues (expected for a derived grammar):');
-      const msg = (e.stderr || e.stdout || e.message || '').toString();
-      console.log('  ' + msg.trim().split('\n').slice(0, 12).join('\n  '));
-    }
-    console.log(`  (artifacts written to ${dir})`);
-  } catch (e: any) {
-    console.log('  could not run CLI test:', e.message);
-  }
-} else {
-  console.log('\ntree-sitter CLI not found — structural validation only (not a failure).');
-}
-
-console.log(`\n${ok}/${ok + fail} structural checks pass`);
-process.exit(fail === 0 ? 0 : 1);
diff --git a/test/treesitter-yaml-bench.ts b/test/treesitter-yaml-bench.ts
deleted file mode 100644
index db6190d..0000000
--- a/test/treesitter-yaml-bench.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-// YAML tree-sitter accuracy bench (issue #3): how many VALID yaml-test-suite inputs the DERIVED
-// YAML tree-sitter parses with no ERROR/MISSING node. "Valid" = the `yaml` package accepts the input
-// (so a failure is the tree-sitter grammar's, not a malformed sample). The corpus is extracted from
-// the yaml-test-suite src meta-files exactly like test/src-coverage-yaml.ts.
-//
-//   git clone --depth 1 https://github.com/yaml/yaml-test-suite /tmp/yaml-test-suite
-//   cd tree-sitter/yaml && npx tree-sitter generate && npx tree-sitter build --wasm .
-//   node test/treesitter-yaml-bench.ts
-import { readdirSync, readFileSync, existsSync } from 'node:fs';
-import { parse as yamlParse, parseAllDocuments } from 'yaml';
-
-const WASM = 'tree-sitter/yaml/tree-sitter-yaml.wasm';
-const SUITE = '/tmp/yaml-test-suite/src';
-if (!existsSync(WASM)) { console.error(`missing ${WASM} — run: (cd tree-sitter/yaml && npx tree-sitter build --wasm .)`); process.exit(1); }
-if (!existsSync(SUITE)) { console.error(`missing ${SUITE} — git clone --depth 1 https://github.com/yaml/yaml-test-suite /tmp/yaml-test-suite`); process.exit(1); }
-
-const { Parser, Language } = await import('web-tree-sitter');
-await Parser.init();
-const lang = await Language.load(WASM);
-const parser = new Parser();
-parser.setLanguage(lang);
-
-// Decode the suite's visible-whitespace markers to real bytes (same as src-coverage-yaml).
-const decode = (s: string) => s.replace(/␣/g, ' ').replace(/—*»/g, '\t').replace(/[↵∎]/g, '');
-const corpus: string[] = [];
-for (const f of readdirSync(SUITE).filter((n) => n.endsWith('.yaml'))) {
-  try {
-    const meta = yamlParse(readFileSync(`${SUITE}/${f}`, 'utf8'));
-    for (const t of (Array.isArray(meta) ? meta : [meta])) if (t && typeof t.yaml === 'string') corpus.push(decode(t.yaml));
-  } catch { /* skip meta-files that don't round-trip */ }
-}
-const valid = corpus.filter((c) => { try { return parseAllDocuments(c).every((d: any) => d.errors.length === 0); } catch { return false; } });
-
-function hasError(node: any): boolean {
-  if (node.type === 'ERROR' || node.isError === true || node.isMissing === true) return true;
-  for (let i = 0; i < node.childCount; i++) { const c = node.child(i); if (c && hasError(c)) return true; }
-  return false;
-}
-
-let ok = 0;
-for (const c of valid) { const tree = parser.parse(c); if (tree && !hasError(tree.rootNode)) ok++; }
-const pct = ((100 * ok) / valid.length).toFixed(1);
-console.log(`YAML corpus: ${corpus.length} inputs (${valid.length} valid per the yaml package).`);
-console.log(`YAML tree-sitter accuracy: ${ok}/${valid.length} valid inputs parse ERROR-free (${pct}%).`);
-console.log(`##TSYAML## ${JSON.stringify({ name: 'YAML', engine: 'tree-sitter (derived)', valid: valid.length, errorFree: ok, pct: Number(pct) })}`);
diff --git a/test/tsgo-parsebench/main.go b/test/tsgo-parsebench/main.go
deleted file mode 100644
index 792e942..0000000
--- a/test/tsgo-parsebench/main.go
+++ /dev/null
@@ -1,43 +0,0 @@
-// Parse-only self-bench for test/profile-portable-peers.mjs (stdin → N iterations → ms/iter).
-// Built with a go.mod that `replace`s github.com/microsoft/typescript-go → $TSGO_REPO.
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"time"
-
-	"github.com/microsoft/typescript-go/internal/ast"
-	"github.com/microsoft/typescript-go/internal/core"
-	"github.com/microsoft/typescript-go/internal/parser"
-)
-
-func parse(src string) {
-	_ = parser.ParseSourceFile(ast.SourceFileParseOptions{
-		FileName: "/bench.js",
-		Path:     "/bench.js",
-	}, src, core.ScriptKindJS)
-}
-
-func main() {
-	data, _ := io.ReadAll(os.Stdin)
-	src := string(data)
-	if len(os.Args) > 1 {
-		iters, err := strconv.Atoi(os.Args[1])
-		if err != nil || iters <= 0 {
-			os.Exit(2)
-		}
-		for i := 0; i < 3; i++ {
-			parse(src)
-		}
-		t0 := time.Now()
-		for i := 0; i < iters; i++ {
-			parse(src)
-		}
-		fmt.Printf("%.4f\n", float64(time.Since(t0).Nanoseconds())/1e6/float64(iters))
-		return
-	}
-	parse(src)
-}
diff --git a/test/verify-rejects.ts b/test/verify-rejects.ts
deleted file mode 100644
index bc97765..0000000
--- a/test/verify-rejects.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-// Rigor check for the "error-test" bucket: failing a file that TS also rejects
-// only counts as *correct* if we reject for the RIGHT reason — i.e. we reach at
-// least as far as TS's first syntax error before bailing. If our parser chokes
-// EARLIER than TS's first diagnostic, the code before that point is valid TS we
-// silently can't parse — a hidden gap hiding behind the "intentional error" label.
-import { createParser } from '../src/gen-parser.ts';
-import { readdir } from 'fs/promises';
-import { readFileSync } from 'fs';
-import { join } from 'path';
-import ts from 'typescript';
-
-const grammar = (await import('../typescript.ts')).default;
-const { parse } = createParser(grammar);
-const baseDir = '/tmp/ts-repo/tests/cases/conformance';
-const SLACK = 8; // chars of tolerance (token boundary / trivia differences)
-
-async function allTsFiles(dir: string): Promise<string[]> {
-  const out: string[] = [];
-  for (const e of await readdir(dir, { withFileTypes: true })) {
-    const full = join(dir, e.name);
-    if (e.isDirectory()) out.push(...await allTsFiles(full));
-    else if (e.name.endsWith('.ts') && !e.name.endsWith('.d.ts')) out.push(full);
-  }
-  return out;
-}
-
-const isMulti = (t: string) => /^\s*\/\/\s*@filename:/im.test(t);
-// How far our parser actually reached: prefer the `farthest` backtracking mark,
-// else the primary error offset.
-function ourReach(msg: string): number | null {
-  const far = msg.match(/farthest: offset (\d+)/);
-  if (far) return +far[1];
-  const at = msg.match(/offset (\d+)/);
-  return at ? +at[1] : null;
-}
-
-const files = (await allTsFiles(baseDir)).sort();
-let agree = 0, early = 0, unknown = 0, oracleCrash = 0;
-const earlies: { file: string; ourReach: number; tsFirst: number; ctx: string }[] = [];
-
-for (const file of files) {
-  const code = readFileSync(file, 'utf-8');
-  if (isMulti(code)) continue;                 // single-file only (clean comparison)
-  let msg = '';
-  try { parse(code); continue; } catch (e: any) { msg = e.message; }  // only files we FAIL
-
-  // the oracle itself can die on malformed input (e.g. a Debug.assert inside
-  // tsc's `await using` paths) — a crashed oracle has no verdict, count + skip
-  let sf;
-  try {
-    sf = ts.createSourceFile('t.ts', code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  } catch {
-    oracleCrash++;
-    continue;
-  }
-  const diags = (sf as any).parseDiagnostics ?? [];
-  if (diags.length === 0) continue;            // that's a REAL gap, handled elsewhere
-
-  const tsFirst = Math.min(...diags.map((d: any) => d.start ?? Infinity));
-  const reach = ourReach(msg);
-  if (reach == null) { unknown++; continue; }
-
-  if (reach >= tsFirst - SLACK) {
-    agree++;                                    // we got to (or past) TS's first error → right reason
-  } else {
-    early++;                                    // we bailed on valid code BEFORE the error
-    earlies.push({ file: file.replace(baseDir + '/', ''), ourReach: reach, tsFirst, ctx: JSON.stringify(code.slice(Math.max(0, reach - 40), reach + 15)) });
-  }
-}
-
-console.log(`Single-file error-tests we fail: ${agree + early + unknown}`);
-console.log(`  AGREE (reach >= TS first error - ${SLACK}) : ${agree}  ← rejected for the right reason`);
-console.log(`  EARLY (bail before TS's error)            : ${early}  ← hidden gap: valid code we can't parse`);
-console.log(`  UNKNOWN (no offset in our error)          : ${unknown}`);
-if (oracleCrash > 0) console.log(`  ORACLE-CRASH (tsc threw; no verdict)      : ${oracleCrash}`);
-if (earlies.length) {
-  console.log(`\n===== EARLY (hidden gaps) =====`);
-  earlies.sort((a, b) => (a.tsFirst - a.ourReach) - (b.tsFirst - b.ourReach));
-  for (const e of earlies) console.log(`  ${e.file}\n      ours@${e.ourReach} vs TS@${e.tsFirst} (gap ${e.tsFirst - e.ourReach})  near ${e.ctx}`);
-}