parseman 0.59.3 → 0.60.1

package/src/types.ts

@@ -58,14 +58,14 @@ export type ParserDef =
   // force interpreter fallback). Absent under runtime compile() — the real gate
   // closures live in `gates`.
   | { tag: 'choice';    parsers: Combinator<unknown>[]; gates: (((state: unknown) => boolean) | null)[]; gateSrcs?: (string | null)[]; disjoint: boolean; strategy: ChoiceStrategy; autoNot: (AutoNotCheck[] | null)[] }
-  | { tag: 'dispatch';  selector: Combinator<string>; cases: readonly DispatchCase[]; matchers?: readonly DispatchMatcherCase[] | undefined; otherwise?: Combinator<unknown> | undefined; otherwiseUsesRouted?: boolean | undefined }
-  | { tag: 'attempt';   parser: Combinator<unknown>; /** `attempt(p, { contain: true })`: a committed failure inside is reported uncommitted. */ contain?: true }
+  | { tag: 'dispatch';  selector: Combinator<string>; cases: readonly DispatchCase[]; matchers?: readonly DispatchMatcherCase[] | undefined; otherwise?: Combinator<unknown> | undefined; otherwiseUsesRouted?: boolean | undefined; otherwiseCommit?: false | undefined }
+  | { tag: 'attempt';   parser: Combinator<unknown>; /** `attempt(p, { contain: true })`: a committed failure inside is reported uncommitted. */ contain?: true; /** The interpreter tests the child's live `_meta.firstSet` before entering it: its set was finite when this was built. */ guarded?: true }
   // The TAG carries NULLABILITY (what every downstream switch keys on): `many` is
   // the nullable min-0 repeat, `oneOrMore` the non-nullable min>=1 one. `min`/`max`
   // carry the actual ITEM bounds (`many(x, { min: 3, max: 8 })` is a `oneOrMore`
   // def with `min: 3, max: 8`). `max` absent = unbounded.
-  | { tag: 'many';      parser: Combinator<unknown>; min: 0; max?: number; valueUnused?: boolean }
-  | { tag: 'oneOrMore'; parser: Combinator<unknown>; min: number; max?: number; valueUnused?: boolean }
+  | { tag: 'many';      parser: Combinator<unknown>; min: 0; max?: number; valueUnused?: boolean; /** The interpreter tests the child's live `_meta.firstSet` before entering it: its set was finite when this was built. */ guarded?: true }
+  | { tag: 'oneOrMore'; parser: Combinator<unknown>; min: number; max?: number; valueUnused?: boolean; /** The interpreter tests the child's live `_meta.firstSet` before entering it: its set was finite when this was built. */ guarded?: true }
   | { tag: 'optional';  parser: Combinator<unknown> }
   // `min`/`max` count ITEMS, not separators. `min: 0` (the default) is
   // `(item (sep item)*)?` — NULLABLE, matches the empty string. `min >= 1` is
@@ -92,7 +92,7 @@ export type ParserDef =
   // it requires, so it carries `parser`'s first-set and a leading `peek()` gates
   // its choice arm (see `isPositiveLookahead` / `sequenceFirstSet`).
   | { tag: 'peek';    parser: Combinator<unknown> }
-  | { tag: 'node';     type?: string; parser: Combinator<unknown>; build?: ((children: ReadonlyArray<unknown>, fields: FieldMap | undefined, span: { start: number; end: number }, rawChildren: ReadonlyArray<unknown>, triviaLog: readonly number[], state: unknown) => unknown) | undefined; buildSrc?: string; /** The IDENTIFIER the type argument was written as at the `node()` call site, when it was a plain identifier rather than a literal — ANALYSIS ONLY, never emitted. Lets the inline-`mk` matcher recognise `node(t, …, (…) => mk(t, …))` from a factory, where the two `t`s are provably one binding. */ typeSrc?: string; /** Resolved source of a NAMED `buildSrc` — ANALYSIS ONLY, never emitted. See `buildAnalysisSrc`. */ buildSigSrc?: string; /** Macro analysis proved the fourth formal (`rawChildren`) unreferenced. Never inferred from an author-declared `buildArity`; carried through composed IR. */ buildRawUnused?: true; /** Declared positional arity of `build`: author-declared via `node(..., { buildArity })`, or resolved from the reducer's declaration. Wins over source inspection. */ buildArity?: number; /** Why arity could not be resolved, for the diagnostic. */ buildArityUnresolved?: string; buildStaticError?: readonly string[]; /** Import provenance for a direct builder's free names — each `{ local, source, imported }` lets a downstream compose() re-emit `import { imported as local } from source` so the inlined builder source can bind. Carried through the IR round-trip. */ buildImports?: ReadonlyArray<{ local: string; source: string; imported: string }>; unwrap?: boolean; collapse?: boolean; project?: number; captureTrivia?: boolean; trailingTrivia?: boolean; tags?: readonly string[] }
+  | { tag: 'node';     type?: string; parser: Combinator<unknown>; build?: ((children: ReadonlyArray<unknown>, fields: FieldMap | undefined, span: { start: number; end: number }, rawChildren: ReadonlyArray<unknown>, triviaLog: readonly number[], state: unknown) => unknown) | undefined; buildSrc?: string; /** The IDENTIFIER the type argument was written as at the `node()` call site, when it was a plain identifier rather than a literal — ANALYSIS ONLY, never emitted. Lets the inline-`mk` matcher recognise `node(t, …, (…) => mk(t, …))` from a factory, where the two `t`s are provably one binding. */ typeSrc?: string; /** Resolved source of a NAMED `buildSrc` — ANALYSIS ONLY, never emitted. See `buildAnalysisSrc`. */ buildSigSrc?: string; /** Macro analysis proved the fourth formal (`rawChildren`) unreferenced. Never inferred from an author-declared `buildArity`; carried through composed IR. */ buildRawUnused?: true; /** Declared positional arity of `build`: author-declared via `node(..., { buildArity })`, or resolved from the reducer's declaration. Wins over source inspection. */ buildArity?: number; /** Why arity could not be resolved, for the diagnostic. */ buildArityUnresolved?: string; buildStaticError?: readonly string[]; /** Import provenance for a direct builder's free names — each `{ local, source, imported }` lets a downstream compose() re-emit `import { imported as local } from source` so the inlined builder source can bind. Carried through the IR round-trip. */ buildImports?: ReadonlyArray<{ local: string; source: string; imported: string }>; unwrap?: boolean; collapse?: boolean; project?: number; captureTrivia?: boolean; trailingTrivia?: boolean; tags?: readonly string[]; /** The interpreter tests the child's live `_meta.firstSet` before entering it: its set was finite when this was built. */ guarded?: true }
   // `predSrc`/`extraSrc` (set by the macro evaluator): SOURCE TEXT of the guard
   // predicate / the withCtx `extra` value, so codegen inlines them into `_mf`
   // rather than pushing a `null` source. Absent under runtime compile() (the real
@@ -461,6 +461,13 @@ export type ParseError = {
 export type ParserMeta = {
   /** Character codes / ranges that can start this parser (for choice dispatch) */
   firstSet: FirstSet
+  /**
+   * Set only by `regex()` for a pattern that can match empty: the first chars
+   * of its NON-EMPTY matches. `firstSet` stays `any` for such a pattern, because
+   * it may match empty anywhere; a sequence, which tracks nullability itself,
+   * unions this set with the next term's instead (`sequenceSet`).
+   */
+  consumingFirstSet?: FirstSet
   /** Whether this parser can consume a newline character */
   canMatchNewline: boolean
   /** Whether this parser is marked as trivia (auto-skip) */

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.59.3'
+export const PARSEMAN_VERSION = '0.60.1'

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()
-}