parseman 0.60.0 → 0.60.2

package/src/table/exec.ts

@@ -75,60 +75,6 @@ import { FAIL, newEndCell, type EndCell } from './cell.ts'
 import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
 import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA, LEAD, triviaFieldCapture } from '../combinators/field-trivia.ts'
 
-/**
- * DIAGNOSTIC ROW COUNTER — off unless `PM_TABLE_COUNT=1` at process start.
- *
- * Read ONCE, at module load, into a module const, so this is not the per-parse
- * option branch G5 forbids: with the variable false the whole thing folds away
- * after tier-up. It exists because "too many rows" and "each row too slow" are
- * different defects with the same symptom, and only a count separates them.
- * No timing run in this repo may set it — see `bench/jess/table-rows.ts`.
- */
-export const tableCounters: {
-  rows: number
-  byOp: Int32Array
-  /** Distinct reducer/host functions actually reaching each shared call site. */
-  sites: Map<string, Set<unknown>>
-  /**
-   * SPECULATION AT UNGATED CHOICES. `encode.ts:368-376` gives a choice its
-   * first-char dispatch only when NO arm is nullable, ALL arms are pairwise
-   * disjoint and ALL map to a char class; any one failure ungates every arm of
-   * the site, which then runs the linear loop below. Codegen has no such
-   * all-or-nothing rule — `emitFirstMatch` guards each arm on its OWN first set
-   * — so these counts are work the table does and the compiled engine does not.
-   *
-   * `ungatedEntries` is arms entered there; `ungatedFails` is those that then
-   * failed, which is pure waste by construction: a failing arm consumed nothing
-   * the winning arm will not scan again.
-   */
-  ungatedEntries: number
-  ungatedFails: number
-  /** Rows executed INSIDE failed ungated arms — the subtree each wasted entry drags. */
-  ungatedFailRows: number
-  gatedEntries: number
-  /** Arm entries DECLINED by the per-arm class gate — the work this change removes. */
-  armGateSkips: number
-} = { rows: 0, byOp: new Int32Array(64), sites: new Map(), ungatedEntries: 0, ungatedFails: 0, ungatedFailRows: 0, gatedEntries: 0, armGateSkips: 0 }
-
-const COUNT = process.env.PM_TABLE_COUNT === '1'
-
-function siteFn(site: string, fn: unknown): void {
-  let s = tableCounters.sites.get(site)
-  if (s === undefined) { s = new Set(); tableCounters.sites.set(site, s) }
-  s.add(fn)
-}
-
-export function resetTableCounters(): void {
-  tableCounters.rows = 0
-  tableCounters.byOp = new Int32Array(64)
-  tableCounters.sites = new Map()
-  tableCounters.ungatedEntries = 0
-  tableCounters.ungatedFails = 0
-  tableCounters.ungatedFailRows = 0
-  tableCounters.gatedEntries = 0
-  tableCounters.armGateSkips = 0
-}
-
 const EMPTY_TL: readonly number[] = Object.freeze([])
 const EMPTY_FX: string[] = []
 const ROUTED_FX: string[] = ['routed()']
@@ -380,7 +326,6 @@ function makeDriver(
     // recursing, so the reference driver's stack grows with the grammar's
     // nesting, not with its gate rows.
     rows: for (;;) {
-    if (COUNT) { tableCounters.rows++; tableCounters.byOp[code[ip]!]!++ }
     switch (code[ip]) {
       case OP_LIT: {
         const s = k[code[ip + 1]!] as string
@@ -891,7 +836,6 @@ function makeDriver(
           // Running it through `exec` at the POST-scan position would find the gap
           // already consumed and answer "adjacent" unconditionally.
           if (code[child] === OP_ADJ) {
-            if (COUNT) { tableCounters.rows++; tableCounters.byOp[OP_ADJ]!++ }
             const ki = code[child + 2]!
             if (!adjacencyHolds(input, cur, ctx, code[child + 1] === 1, ki < 0 ? undefined : k[ki] as readonly string[])) {
               ctx._fe = cur; ctx._fx = fx[code[child + 3]!] as string[]
@@ -927,10 +871,6 @@ function makeDriver(
           // LIT/RX in place removes both. The duplication is in the DRIVER,
           // which ships once for every grammar — the cost this design trades on.
           const cop = code[child]
-          // The two inline terminals below execute a ROW without going through
-          // `exec`, so the counter has to see them or the row count understates
-          // exactly where the driver already won.
-          if (COUNT && (cop === OP_LIT || cop === OP_RX)) { tableCounters.rows++; tableCounters.byOp[cop]!++ }
           if (cop === OP_LIT) {
             const lit = k[code[child + 1]!] as string
             if (!input.startsWith(lit, cur)) {
@@ -971,7 +911,6 @@ function makeDriver(
           const reducer = code[ip + 1]!
           if (reducer < 0) return values![~reducer]
           const fn = fns[reducer] as (value: unknown, span: { start: number; end: number }) => unknown
-          if (COUNT) siteFn('SEQX fn()', fn)
           return fn(values, { start: pos, end: cur })
         }
         return values
@@ -1003,7 +942,6 @@ function makeDriver(
           }
           if (arm >= 0) {
             ctx._fc = false
-            if (COUNT) tableCounters.gatedEntries++
             const v = exec(code[base + arm]!, input, pos, ctx)
             if (v !== FAIL) return v
             // THE CUT. `dispatch()` is the library's one true cut: once its
@@ -1085,7 +1023,6 @@ function makeDriver(
           // Under a completion probe every arm is entered, as the interpreter's
           // `firstMatch` enters it: its opener then reaches the probe (`failAt`).
           if (ctx._probe === undefined && cls !== undefined && cls !== null && !classHas(cls, c)) {
-            if (COUNT) tableCounters.armGateSkips++
             // THE GATED ARM STILL REPORTS. The interpreter has no char gate: it
             // enters the arm, the arm's opener fails, and its static set is what
             // lands in the accumulation. Declining to enter must not also decline
@@ -1094,11 +1031,8 @@ function makeDriver(
             continue
           }
           ctx._fc = false
-          if (COUNT) tableCounters.ungatedEntries++
-          const rows0 = COUNT ? tableCounters.rows : 0
           const v = exec(code[base + i]!, input, pos, ctx)
           if (v !== FAIL) return v
-          if (COUNT) { tableCounters.ungatedFails++; tableCounters.ungatedFailRows += tableCounters.rows - rows0 }
           const at = ctx._fe ?? pos
           if (at > best) { best = at; acc = undefined }
           if (at === best) push(ctx._fx)
@@ -1421,7 +1355,6 @@ function makeDriver(
         const v = exec(code[ip + 2]!, input, pos, ctx)
         if (v === FAIL) return FAIL
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
-        if (COUNT) siteFn('XFORM fn()', fn)
         return fn(v, { start: pos, end: EC.e })
       }
 
@@ -1463,7 +1396,6 @@ function makeDriver(
         if (v === FAIL) return FAIL
         const end = EC.e
         const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
-        if (COUNT) siteFn('LEAF fn()', fn)
         const out = fn(v, { start: pos, end })
         if (wasCapturing) pushCstLeaf(ctx, {
           _tag: 'leaf',
@@ -1566,7 +1498,6 @@ function makeDriver(
               children: readonly unknown[], fields: FieldMap | undefined, span: { start: number; end: number },
               rawChildren: readonly unknown[], triviaLog: readonly number[], state: unknown,
             ) => unknown
-            if (COUNT) siteFn('NODE build()', build)
             nd = build(kids, fieldMap, span, cap.rawChildren, (flags & 4) !== 0 || hostCst ? cap.triviaLog : EMPTY_TL, st)
           }
         } else if (host !== undefined) {

package/src/table/ops.ts

@@ -74,13 +74,7 @@ export const OP_XFORM = 9
  * from the reducer's declared arity by the same analysis codegen runs, and
  * forced on under `hostMode: 'cst'`. The driver reads the bits and re-derives
  * nothing.
- *
- * TWO ENCODERS SHARE THIS OPCODE and they do NOT agree on its length. The layout
- * above is `encode.ts` / `exec.ts`. `encode-baseline.ts` / `exec-baseline.ts` emit
- * the FOUR-word form `NODE b c flags` with bits 2 and 3 only, and refuse
- * `collapse` / `unwrap` / `project` outright. Neither driver walks the stream by
- * instruction length, so the divergence is contained — but read the pair you are
- * in, not this comment alone. */
+ */
 export const OP_NODE = 10
 /** `RULE r` — `r` indexes `prog.rules`. */
 export const OP_RULE = 11
@@ -93,9 +87,6 @@ export const OP_NOT = 13
  * `['peek(<child tag>)']`, because `peek.ts:60` DISCARDS the body's expectation:
  * a lookahead's failure is "the guard did not hold", not a request for whatever
  * token the body happened to stop on.
- *
- * `encode-baseline.ts` / `exec-baseline.ts` emit and read the two-word form and
- * are internally consistent; read the pair you are in.
  */
 export const OP_PEEK = 14
 /** `LEAF f c` — `leaf()`: reduce, then record as a spanned leaf. */

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.60.0'
+export const PARSEMAN_VERSION = '0.60.2'

package/dist/table/encode-baseline.d.ts

@@ -1,16 +0,0 @@
-import type { Combinator } from '../types.ts';
-import type { TableProgram } from './program.ts';
-/** Settings that select the TABLE'S CONTENTS. They never reach the driver. */
-export type TableSettings = {
-    readonly hostMode?: 'ast' | 'cst';
-    readonly trackLines?: boolean;
-};
-/**
- * Encode a rule map into ONE table for ONE settings pair.
- *
- * Two settings pairs give two programs and therefore two cached reference
- * tables; the driver that reads them is the same function in both cases and
- * never sees `settings`.
- */
-export declare function encodeTableBaseline(ruleMap: Record<string, Combinator<unknown>>, settings?: TableSettings): TableProgram;
-//# sourceMappingURL=encode-baseline.d.ts.map

package/dist/table/encode-baseline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"encode-baseline.d.ts","sourceRoot":"","sources":["../../src/table/encode-baseline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,aAAa,CAAA;AAUlE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAQhD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,CAAA;IACjC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAA;CAC9B,CAAA;AAqTD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EAC5C,QAAQ,GAAE,aAAkB,GAC3B,YAAY,CAId"}

package/dist/table/exec-baseline.d.ts

@@ -1,9 +0,0 @@
-import { type CompactProgram, type TableProgram, type TableRule } from './program.ts';
-/**
- * Turn a program into the rule map a compiled artifact exports.
- *
- * The entries have the SAME signature as codegen rule functions, so `run()`,
- * the linker's public wrappers and every consumer are unchanged.
- */
-export declare function execRulesBaseline(source: TableProgram | CompactProgram): Record<string, TableRule>;
-//# sourceMappingURL=exec-baseline.d.ts.map

package/dist/table/exec-baseline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exec-baseline.d.ts","sourceRoot":"","sources":["../../src/table/exec-baseline.ts"],"names":[],"mappings":"AAWA,OAAO,EAEL,KAAK,cAAc,EAA6C,KAAK,YAAY,EAAE,KAAK,SAAS,EAClG,MAAM,cAAc,CAAA;AAggBrB;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAwBlG"}

package/src/table/encode-baseline.ts

@@ -1,346 +0,0 @@
-import type { Combinator, FirstSet, ParserDef } from '../types.ts'
-import { firstSetOf, matchesEmpty } from '../combinators/first-set.ts'
-import { leadRanges } from '../lead-ranges.ts'
-import { deriveExpected } from '../combinators/expect.ts'
-import { buildReadsState, buildReadsTrivia } from '../compiler/build-arity.ts'
-import {
-  OP_CHOICE, OP_EMPTY, OP_GATE, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_NODE, OP_NOT, OP_OPT,
-  OP_PEEK, OP_REP, OP_REPV, OP_RULE, OP_RX, OP_SEQ, OP_SEQV, OP_XFORM,
-  OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_EXPECT,
-} from './ops.ts'
-import type { TableProgram } from './program.ts'
-
-/** Raised when a construct has no opcode yet. Prototype scope is explicit. */
-class UnsupportedConstructBaseline extends Error {
-  readonly tag: string
-  constructor(tag: string) { super(`table lowering: no opcode for '${tag}'`); this.tag = tag }
-}
-
-/** Settings that select the TABLE'S CONTENTS. They never reach the driver. */
-export type TableSettings = {
-  readonly hostMode?: 'ast' | 'cst'
-  readonly trackLines?: boolean
-}
-
-type Emitted = { readonly ip: number }
-
-/**
- * Do these first sets share no character?
- *
- * `any` and `empty` are never disjoint from anything — an over-approximating arm
- * has to fall back to ordered first-match or the choice silently picks the wrong
- * one. See the `Keyword`-ahead-of-`Num` case in the choice encoder.
- */
-function disjointSets(sets: readonly FirstSet[]): boolean {
-  const seen: Array<{ lo: number; hi: number }> = []
-  for (const fs of sets) {
-    if (fs.kind !== 'ranges' || fs.ranges.length === 0) return false
-    for (const r of leadRanges(fs.ranges)) {
-      for (const p of seen) if (r.lo <= p.hi && p.lo <= r.hi) return false
-      seen.push(r)
-    }
-  }
-  return true
-}
-
-class Encoder {
-  code: number[] = []
-  k: unknown[] = []
-  fns: unknown[] = []
-  cc: string[] = []
-  fx: (readonly string[])[] = []
-  disp: (readonly number[])[] = []
-  rules: Record<string, number> = {}
-
-  private kIndex = new Map<unknown, number>()
-  private ccIndex = new Map<string, number>()
-  private fxIndex = new Map<string, number>()
-  /** Memoized by combinator identity: a shared sub-combinator is ONE row. */
-  private memo = new Map<Combinator<unknown>, number>()
-  private pending = new Map<Combinator<unknown>, number[]>()
-
-  readonly settings: TableSettings
-  /** Resolved once, HERE, at table-build time — never consulted at run time. */
-  readonly track: boolean
-  constructor(settings: TableSettings) {
-    this.settings = settings
-    this.track = settings.trackLines === true
-  }
-
-  private constant(v: unknown): number {
-    const key = v instanceof RegExp ? `re:${JSON.stringify([v.source, v.flags])}` : v
-    const hit = this.kIndex.get(key)
-    if (hit !== undefined) return hit
-    const i = this.k.length
-    this.k.push(v)
-    this.kIndex.set(key, i)
-    return i
-  }
-
-  private fn(v: unknown): number {
-    const i = this.fns.length
-    this.fns.push(v)
-    return i
-  }
-
-  private expected(list: readonly string[]): number {
-    const key = JSON.stringify(list)
-    const hit = this.fxIndex.get(key)
-    if (hit !== undefined) return hit
-    const i = this.fx.length
-    this.fx.push(list)
-    this.fxIndex.set(key, i)
-    return i
-  }
-
-  /** A first set becomes a char class STRING of `[lo, hi]` pairs, or −1 for `any`. */
-  private charClass(fs: FirstSet): number {
-    if (fs.kind !== 'ranges' || fs.ranges.length === 0) return -1
-    let spec = ''
-    for (const r of fs.ranges) spec += String.fromCharCode(r.lo, r.hi)
-    const hit = this.ccIndex.get(spec)
-    if (hit !== undefined) return hit
-    const i = this.cc.length
-    this.cc.push(spec)
-    this.ccIndex.set(spec, i)
-    return i
-  }
-
-  private emit(...words: number[]): number {
-    const ip = this.code.length
-    for (const w of words) this.code.push(w)
-    return ip
-  }
-
-  /** Reserve `n` operand slots to patch once children are laid out. */
-  private emitHead(op: number, n: number): number {
-    const ip = this.code.length
-    this.code.push(op)
-    for (let i = 0; i < n; i++) this.code.push(0)
-    return ip
-  }
-
-  encodeRule(name: string, p: Combinator<unknown>): void {
-    this.rules[name] = this.node(p).ip
-  }
-
-  node(p: Combinator<unknown>): Emitted {
-    const hit = this.memo.get(p)
-    if (hit !== undefined) return { ip: hit }
-    // Recursion: reserve a trampoline row now, patch its target when the real
-    // body lands. One extra indirection per recursive rule, zero per call site.
-    const inFlight = this.pending.get(p)
-    if (inFlight !== undefined) {
-      const ip = this.emitHead(OP_RULE, 1)
-      inFlight.push(ip + 1)
-      return { ip }
-    }
-    const patches: number[] = []
-    this.pending.set(p, patches)
-    const ip = this.encodeDef(p)
-    this.pending.delete(p)
-    this.memo.set(p, ip)
-    for (const slot of patches) this.code[slot] = ip
-    return { ip }
-  }
-
-  private encodeDef(p: Combinator<unknown>): number {
-    const d = p._def as ParserDef
-    // REFUSE what this frozen copy cannot lower, rather than lowering it wrong.
-    //
-    // `scanTo` and `token` have no `case` below, so they reach `default:` and throw
-    // — a refusal, which is safe. `balanced()` does NOT: it overrides `.parse` and
-    // leaves `_def` as the EAGER INTERIOR with no distinguishing tag, so the switch
-    // would encode the interior, report nothing, and produce a table that parses and
-    // yields a different tree. An ablation measurement taken on a grammar using
-    // `balanced()` would then be comparing against a parser that is not the one
-    // under test. Refused explicitly, since this copy has no OP_CALL to fall back on.
-    if ((p as { _balancedAmbient?: unknown })._balancedAmbient !== undefined) {
-      throw new UnsupportedConstructBaseline('balanced() — the frozen ablation encoder cannot lower it')
-    }
-    switch (d.tag) {
-      case 'literal': {
-        if (d.caseInsensitive) throw new UnsupportedConstructBaseline('literal(caseInsensitive)')
-        return this.emit(this.track ? OP_LIT_TRACK : OP_LIT, this.constant(d.value), this.expected(deriveExpected(p)))
-      }
-      case 'regex': {
-        const flags = d.flags.includes('y') ? d.flags : `${d.flags}y`
-        return this.emit(this.track ? OP_RX_TRACK : OP_RX, this.constant(new RegExp(d.source, flags)), this.expected(deriveExpected(p)))
-      }
-      case 'keywords': {
-        // `keywords()` compiles to ONE sticky regex and pushes a leaf — which is
-        // exactly what OP_RX does. Rebuilding the same regex here needs no new
-        // opcode. Construction mirrors src/combinators/keywords.ts:87-106; the
-        // words arrive already sorted longest-first on the def.
-        const alt = d.words.map(w => w.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')
-        const boundary = d.boundary ? `(?![${d.boundary}])` : ''
-        const flags = d.caseInsensitive ? 'iy' : 'uy'
-        return this.emit(
-          this.track ? OP_RX_TRACK : OP_RX,
-          this.constant(new RegExp(`(?:${alt})${boundary}`, flags)),
-          this.expected(deriveExpected(p)),
-        )
-      }
-      case 'expect': {
-        // `expect()` NEVER fails: on a failed child it yields a ParseError value
-        // at zero width. That is a distinct outcome, so it gets its own row.
-        return this.emit(OP_EXPECT, this.node(d.parser).ip, this.expected([...d.expected]))
-      }
-      case 'sequence': {
-        const kids = d.parsers.map(c => this.node(c).ip)
-        const head = this.emitHead(d.valueUnused ? OP_SEQV : OP_SEQ, 1 + kids.length)
-        this.code[head + 1] = kids.length
-        for (let i = 0; i < kids.length; i++) this.code[head + 2 + i] = kids[i]!
-        return head
-      }
-      case 'choice': {
-        if (d.gates.some(g => g !== null)) throw new UnsupportedConstructBaseline('choice(gate:)')
-        // Arm ORDER is semantics. `literalsLongestFirst` / `sharedPrefix` /
-        // `greedyClassify` reorder or restructure the arms, so encoding them as
-        // a plain ordered choice would pick a different arm and build a
-        // different tree while still parsing. Refuse them rather than lower them
-        // wrong.
-        // `greedyClassify` runs ONE arm and then re-attributes the match to a
-        // DIFFERENT arm by string equality, re-applying that arm's transforms.
-        // That is a different execution, not a different order, so it is refused
-        // rather than approximated.
-        if (d.strategy.tag === 'greedyClassify') throw new UnsupportedConstructBaseline('choice(strategy=greedyClassify)')
-        // `autoNot` rejects an arm that matched but is followed by a char in a
-        // sibling's first set, so a later arm can win. Ignoring it would pick a
-        // different arm and build a different tree behind a successful parse.
-        if (d.autoNot.some(a => a !== null)) throw new UnsupportedConstructBaseline('choice(autoNot)')
-        // ORDER is the only thing the remaining strategies change, and order is
-        // table data. `literalsLongestFirst` carries its order explicitly;
-        // `sharedPrefix` is documented in choice.ts:52 as a firstMatch
-        // specialization, so declared order is already correct for it.
-        const order = d.strategy.tag === 'literalsLongestFirst'
-          ? d.strategy.sortedIndices
-          : d.parsers.map((_, i) => i)
-        const arms = order.map(i => d.parsers[i]!)
-        const kids = arms.map(c => this.node(c).ip)
-        // O(1) first-char dispatch is only SOUND when the arms are disjoint.
-        // With overlapping first sets, "the first arm whose class contains this
-        // char" is not "the first arm that matches": a `Keyword` arm whose first
-        // set over-approximates to include digits was selected ahead of `Num`
-        // for the input `0` — the parse still succeeded, and only the TREE moved.
-        // Disjointness is computed HERE, not read off `d.disjoint`. That flag is
-        // set when `choice()` is CONSTRUCTED, at which point `g.X` arms are
-        // unresolved refs whose first set is `any` — so every recursive grammar
-        // reports non-disjoint and loses its dispatch. (Codegen has the same
-        // problem and solves it the same way: a placeholder resolved at fuse.)
-        let dispIdx = -1
-        if (arms.every(a => !matchesEmpty(a))) {
-          const sets = arms.map(a => firstSetOf(a))
-          if (disjointSets(sets)) {
-            const classes = sets.map(fs => this.charClass(fs))
-            if (classes.every(c => c >= 0)) {
-              dispIdx = this.disp.length
-              this.disp.push(classes)
-            }
-          }
-        }
-        const head = this.emitHead(OP_CHOICE, 2 + kids.length)
-        this.code[head + 1] = dispIdx
-        this.code[head + 2] = kids.length
-        for (let i = 0; i < kids.length; i++) this.code[head + 3 + i] = kids[i]!
-        return head
-      }
-      case 'many':
-      case 'oneOrMore': {
-        const child = this.node(d.parser).ip
-        return this.emit(
-          d.valueUnused ? OP_REPV : OP_REP,
-          child, d.tag === 'many' ? 0 : d.min, d.max ?? -1, -1, 0,
-        )
-      }
-      case 'sepBy': {
-        const child = this.node(d.parser).ip
-        const sep = this.node(d.separator).ip
-        return this.emit(OP_REP, child, d.min, d.max ?? -1, sep, d.trailing === 'allow' ? 1 : 0)
-      }
-      case 'optional':
-        return this.emit(OP_OPT, this.node(d.parser).ip)
-      case 'transform': {
-        const child = this.node(d.parser).ip
-        return this.emit(OP_XFORM, this.fn(d.fn), child)
-      }
-      case 'leaf': {
-        const child = this.node(d.parser).ip
-        return this.emit(d.cstValue === 'source' ? OP_SOURCE_LEAF : OP_LEAF, this.fn(d.fn), child)
-      }
-      case 'node': {
-        if (d.unwrap || d.collapse || d.project !== undefined) throw new UnsupportedConstructBaseline('node(unwrap|collapse|project)')
-        if (d.build === undefined) throw new UnsupportedConstructBaseline('node(no build)')
-        const child = this.node(d.parser).ip
-        // Capture flags, resolved HERE from the reducer's declared arity using the
-        // same analysis codegen runs (`src/compiler/build-arity.ts`). `hostMode:
-        // 'cst'` forces them on, exactly as the emitted `cstOut` path does. The
-        // driver reads a bit; it re-derives nothing and sees no setting.
-        const cstOut = this.settings.hostMode === 'cst'
-        const flags = (cstOut || buildReadsTrivia(d) ? 4 : 0) | (cstOut || buildReadsState(d) ? 8 : 0)
-        const body = this.emit(this.track ? OP_NODE_TRACK : OP_NODE, this.fn(d.build), child, flags)
-        // The rule's own first-set gate — the emitted code's `_ngc` test, as data.
-        // A NULLABLE rule has no gate: it succeeds on input its first set does
-        // not contain (including EOF), so gating it would reject a legal empty
-        // match. Caught by the ladder's `empty` and `garbage` cases.
-        if (matchesEmpty(p)) return body
-        const cls = this.charClass(firstSetOf(p))
-        if (cls < 0) return body
-        return this.emit(OP_GATE, cls, body, this.expected(deriveExpected(p)))
-      }
-      case 'lazy':
-        // A named reference is not a hop: it resolves to the target's row.
-        // Emitting a trampoline here cost one dispatch per reference for nothing.
-        return this.node(d.thunk()).ip
-      case 'not':
-        return this.emit(OP_NOT, this.node(d.parser).ip)
-      case 'peek':
-        return this.emit(OP_PEEK, this.node(d.parser).ip)
-      // A contained transaction changes what an enclosing choice does next, so
-      // it cannot be transparent.
-      case 'attempt':
-        if (d.contain === true) throw new UnsupportedConstructBaseline('attempt(contain)')
-        return this.node(d.parser).ip
-      // Transparent wrappers: no row of their own, no dispatch at run time.
-      case 'token':
-      case 'label':
-      case 'trivia':
-        return this.node(d.parser).ip
-      case 'grammar': {
-        // A trivia scope is a ROW, not a lowering decision: the scope's trivia
-        // combinator goes in the const pool and the driver installs it.
-        if (d.clearTrivia === true) return this.emit(OP_SCOPE, -1, this.node(d.parser).ip)
-        if (d.triviaParser === undefined) return this.node(d.parser).ip
-        return this.emit(OP_SCOPE, this.constant(d.triviaParser), this.node(d.parser).ip)
-      }
-      default:
-        throw new UnsupportedConstructBaseline(d.tag)
-    }
-  }
-
-  finish(): TableProgram {
-    if (this.code.length === 0) this.emit(OP_EMPTY)
-    return {
-      code: this.code, k: this.k, fns: this.fns, cc: this.cc,
-      fx: this.fx, disp: this.disp, dsp: [], rules: this.rules,
-      lines: this.track ? 1 : 0,
-      ...(this.settings.hostMode === undefined ? {} : { hostMode: this.settings.hostMode }),
-    }
-  }
-}
-
-/**
- * Encode a rule map into ONE table for ONE settings pair.
- *
- * Two settings pairs give two programs and therefore two cached reference
- * tables; the driver that reads them is the same function in both cases and
- * never sees `settings`.
- */
-export function encodeTableBaseline(
-  ruleMap: Record<string, Combinator<unknown>>,
-  settings: TableSettings = {},
-): TableProgram {
-  const enc = new Encoder(settings)
-  for (const name of Object.keys(ruleMap)) enc.encodeRule(name, ruleMap[name]!)
-  return enc.finish()
-}