parseman 0.46.0 → 0.47.0

package/src/table/emit-assembly.ts

@@ -0,0 +1,1766 @@
+/**
+ * U4 — THE ASSEMBLY, AS EMITTED SOURCE.
+ *
+ * `assemble.ts` lowers each reachable site to a closure. This file lowers the
+ * same sites to TEXT, compiled once per (grammar × option set) at run start.
+ * Semantics are `assemble.ts`'s, site for site; the identity sweep
+ * (`bench/table-lowering-identity.ts`) gates the two against each other and
+ * against the interpreter, and `expected` is inside the digest it compares.
+ *
+ * ## Why text, and not a rearrangement of `assemble.ts`
+ *
+ * V8 attaches inline-cache feedback per FUNCTION LITERAL, not per closure. The
+ * second closure minted from a `CreateClosure` site moves its `FeedbackCell` to
+ * `kManyClosures`, and the vector is shared from then on. `assemble.ts` mints 18
+ * arity-2 `SEQV` closures for `less/stylesheet` from ONE literal, so the two
+ * child call sites inside that literal see 18 unrelated callees and go
+ * megamorphic — a hash lookup in the megamorphic stub cache, no inlining, no
+ * type feedback for the callee body. No rearrangement of a file that MINTS
+ * closures can produce a distinct literal per site. Emitting one
+ * `function _pf<N>` per site can: inside `_pf12` the call `_pf7(…)` names ONE
+ * binding and stays monomorphic.
+ *
+ * ## What may be shared, and what must be emitted
+ *
+ * A body containing a call to another PIECE must be emitted per site, or the
+ * megamorphism relocates from `assemble.ts` into a shared helper and nothing
+ * changes. That is why `nextTerm` is INLINED at every sequence term here rather
+ * than called.
+ *
+ * The rule this file applies is narrower than "no helpers", and it is the whole
+ * criterion: **a shared emitted-scope helper is sound exactly when it takes no
+ * piece as an argument**, because then it has no call site whose feedback a
+ * second caller could pollute. `_skipTrivia` qualifies — it calls the installed
+ * trivia scanner, which is runtime state in either engine. `nextTerm` does not.
+ *
+ * ## Cycles
+ *
+ * `assemble.ts` needs one forwarding stub per recursive site,
+ * `const fwd = (input, pos, ctx) => target!(input, pos, ctx)` — a SINGLE
+ * function literal that every back-edge in the process funnels through.
+ * Emitted `function` declarations hoist, so a back-edge here is a direct name
+ * reference and the stub does not exist.
+ *
+ * ## Refusal
+ *
+ * Any construct not lowered raises `Unemittable`, naming it. `assemble.ts`
+ * catches that, RECORDS it on the assembly, and falls back to the closure path.
+ * The fallback is observable (`Assembly.emitRefusal`): a silent one would make
+ * a permanently slow path indistinguishable from a fast one, which is exactly
+ * what `encode.ts:1208-1213` refuses to allow for `OP_LIVE`.
+ */
+import type { ParseContext } from '../types.ts'
+import {
+  OP_ADJ, OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE,
+  OP_LABEL, OP_LEAF, OP_LIT, OP_LIT_CI, OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_NAMES,
+  OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT, OP_PEEK, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX,
+  OP_RX_TRACK, OP_SCAN, OP_SCOPE, OP_SCOPE_CAP, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_XFORM,
+} from './ops.ts'
+import type { ResolvedClass, ResolvedTable, TableProgram } from './program.ts'
+import { emitShapeMatch, scanShapeFromRegex } from './scan-shapes.ts'
+import {
+  CAP_OFF, CAP_ON, TRI_NONE, TRI_UNKNOWN, TOP, computeSiteLabels, reachableSites, type SiteLabel,
+} from './site-labels.ts'
+
+/** What the compiled factory hands back — the emitted twin of `Assembly`. */
+export type EmittedPiece = (input: string, pos: number, ctx: ParseContext) => unknown
+export type EmittedAssembly = {
+  readonly pieces: Record<string, EmittedPiece>
+  /** Sites named for `subtreeComb` — the scan pool and the scan-skip sets. */
+  readonly byIp: Record<number, EmittedPiece | undefined>
+  readonly end: () => number
+  readonly begin: (ctx: ParseContext) => void
+  readonly finish: () => void
+}
+/** The `new Function` result. Its parameters are `EMITTED_PARAMS`, in order. */
+export type EmittedFactory = (...args: readonly unknown[]) => EmittedAssembly
+
+/** A construct the emitter does not lower. Names the CONSTRUCT, never a type. */
+export class Unemittable extends Error {
+  readonly construct: string
+  constructor(construct: string) {
+    super(`table emitter: cannot emit ${construct}`)
+    this.name = 'Unemittable'
+    this.construct = construct
+  }
+}
+
+/**
+ * The names the emitted scope is closed over, in the order the factory takes
+ * them. ONE list, so the parameter list and the argument list cannot drift — a
+ * mismatch binds the wrong function to the wrong name and yields a parser that
+ * runs and is wrong, which no type in this file would catch.
+ */
+export const EMITTED_PARAMS = [
+  'EC', 'FAIL', 'K', 'FX', 'FNS', 'MASK', 'CLS', 'AFX', 'TRIVIA', 'TRIVIALABELS', 'TRIVIASCAN',
+  'SCANS', 'DISP', 'DSP', 'EMPTY_FX', 'EMPTY_CH', 'EMPTY_TLOG', 'EMPTY_TL',
+  'cstCaptureActive', 'pushCstLeaf', 'pushCstChild', 'rollbackTriviaAt', 'failAt',
+  'classHas', 'consumeTrivia', 'buildFieldMap', 'projectChild', 'unwrapChild',
+  'demoteCapturedToRaw', 'cstLeavesLen', 'skipTriviaScanned', 'needsDeferredTriviaCommit',
+  'scanTrivia', 'advanceTrivia', 'refuseUnclassifiedRootScope', 'spanLines', 'rawEntry', 'lead',
+  'asciiFoldKey', 'ROUTED_FX',
+  // RECOVERY, bound rather than reimplemented. `SENTS` is the sync sentinel per
+  // char-class index — the emitted twin of `assemble.ts`'s `sentinelFor` memo,
+  // and an interpreted `Combinator` indexed out of an array for the same reason
+  // `SCANS` is. The four functions are `recovery/scan.ts`'s own, so an error's
+  // span, expected set and CST embedding are produced by the SAME code in every
+  // engine and cannot drift.
+  'SENTS', 'matchesAt', 'recoverScan', 'orSentinel', 'captureError',
+] as const
+
+/**
+ * The state the emitted scope owns, and the helpers that touch it.
+ *
+ * `EC` is the assembly's end-position cell, INJECTED (see `cell.ts`) rather
+ * than a slot this scope owns: a mixed assembly runs emitted pieces beside
+ * closure pieces or an `exec.ts` driver, and all three must write one slot or a
+ * cross-engine call reports the end of whatever the other engine last did.
+ * `_pfScan` is the
+ * installed trivia scanner, which `OP_SCOPE` swaps mid-parse and so cannot be a
+ * constant in either engine.
+ *
+ * Every function here is shared by the rule in this file's header: none takes a
+ * piece as an argument.
+ */
+const RUNTIME_PRELUDE = `
+let _pfScan=null
+let _pfHost
+let _pfDepth=0
+const _pfFrames=[]
+function _skipTrivia(input,cur,ctx){
+const s=_pfScan
+if(s!==null&&ctx._triviaLog===undefined&&!(ctx.captureTrivia===true&&(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)))return s(input,cur)
+if(s!==null)return skipTriviaScanned(s,input,cur,ctx)
+if(needsDeferredTriviaCommit(ctx)){const sc=scanTrivia(input,cur,ctx);sc.commit();return sc.end}
+return advanceTrivia(input,cur,ctx)
+}
+function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
+function _pushLeafBuf(ctx,value,s,e){
+const l={_tag:'leaf',value,span:{start:s,end:e}}
+const b=ctx._cstBuf
+if(b.ch!==undefined)b.ch.push(l)
+else if(b.single!==undefined){b.ch=[b.single,l];b.single=undefined}
+else b.single=l
+if(b.raw!==undefined)b.raw.push(l)
+else if(b.rawSingle!==undefined){b.raw=[b.rawSingle,l];b.rawSingle=undefined}
+else b.rawSingle=l
+}
+function _accSet(ax,acc){
+if(ax===undefined||ax.length===0)return acc
+if(acc===undefined)return ax.slice()
+for(const s of ax)acc.push(s)
+return acc
+}
+function _trackLines(ctx,input,end){
+const from=ctx._lineScannedTo??0
+if(end<=from)return
+const starts=ctx._lineStarts
+if(starts===undefined)return
+for(let i=from;i<end;i++)if(input.charCodeAt(i)===10)starts.push(i+1)
+ctx._lineScannedTo=end
+}
+function _rollbackNeeded(ctx){
+return ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined||ctx._cstRawChildren!==undefined||ctx._cstTriviaLog!==undefined||ctx._fields!==undefined||ctx._errors!==undefined||ctx._triviaLog!==undefined||ctx._rootTriviaLog!==undefined
+}
+function _rbBuf(ctx,raw,tl,lv,lg,rt){
+const b=ctx._cstBuf
+const ra=b.raw
+if(ra!==undefined){
+if(raw===0)b.raw=undefined
+else if(raw===1){b.rawSingle=ra[0];b.raw=undefined}
+else if(ra.length!==raw)ra.length=raw
+}else if(raw===0)b.rawSingle=undefined
+const ch=b.ch
+if(ch!==undefined){
+if(lv===0)b.ch=undefined
+else if(lv===1){b.single=ch[0];b.ch=undefined}
+else if(ch.length!==lv)ch.length=lv
+}else if(lv===0)b.single=undefined
+const bt=b.tl
+if(bt!==undefined){
+if(tl===0)b.tl=undefined
+else if(bt.length!==tl)bt.length=tl
+}
+if(ctx._triviaLog!==undefined&&ctx._triviaLog.length!==lg)ctx._triviaLog.length=lg
+if(ctx._rootTriviaLog!==undefined&&ctx._rootTriviaLog.length!==rt)ctx._rootTriviaLog.length=rt
+}
+`
+
+function q(s: string): string {
+  return JSON.stringify(s)
+}
+
+/**
+ * WHICH SIDE SINKS A MARK IN THIS ASSEMBLY HAS TO COVER.
+ *
+ * `_fields` and `_errors` used to be free: `emitRollback`'s own comment argued
+ * that neither could grow in an emitted assembly, because `OP_FIELD` and
+ * `OP_EXPECT` were both unemittable and a table carrying one fell back whole.
+ * Emitting them retires that argument, so the marks come back — but ONLY for a
+ * table that actually contains the writer, which is an emit-time fact about the
+ * program and not a per-parse test.
+ *
+ * Per TABLE and not per SITE, deliberately. A site's subtree reaches through
+ * `OP_RULE` into the rule graph, so "can a field run under this mark" is very
+ * nearly "does the grammar have a field" for every mark that is not a leaf's —
+ * and a per-site answer would buy a handful of sites at the cost of a second
+ * fixpoint walk over the code array.
+ */
+type Sinks = { readonly fd: boolean; readonly er: boolean }
+const NO_SINKS: Sinks = { fd: false, er: false }
+
+/**
+ * The rollback-mark prologue as SSA locals, rather than the eight shared slots
+ * `assemble.ts` writes and reads back.
+ *
+ * `markCst` exists in the closure engine because a `{ raw, tl, lv }` return
+ * would allocate per mark and marks are the most-executed thing in the driver.
+ * Emitted, the question does not arise: a mark is seven locals in a frame the
+ * body already has. Same scalarisation `rollbackCstCaptureAt` documents, one
+ * step further because the source form can take it.
+ */
+function sinkSlots(t: string, s: Sinks): string {
+  return `${s.fd ? `,${t}fd=0` : ''}${s.er ? `,${t}er=0` : ''}`
+}
+function sinkReads(t: string, s: Sinks): string {
+  return `${s.fd ? `\n${t}fd=ctx._fields!==undefined?ctx._fields.length:0` : ''}${s.er ? `\n${t}er=ctx._errors!==undefined?ctx._errors.length:0` : ''}`
+}
+
+function emitMark(t: string, buf: boolean, s: Sinks = NO_SINKS, decl = true): string {
+  // THE SITE IS INSIDE A NODE. `OP_NODE` opens `ctx._cstBuf` unconditionally and
+  // closes it on the way out, so the whole discriminating chain below — which
+  // sink is live, and whether a mark is needed at all — has ONE answer here, and
+  // the pass knows it. What is left is the five loads a mark actually is.
+  //
+  // `decl === false` RE-TAKES a mark into locals that already exist —
+  // `OP_DISPATCH` marks, rolls back to the selector's mark, and marks again.
+  if (buf) {
+    return `${decl ? `let ${t}raw=0,${t}tl=0,${t}lv=0,${t}lg=0,${t}rt=0${sinkSlots(t, s)}\n` : ''}{const b=ctx._cstBuf
+const r=b.raw;${t}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${t}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${t}tl=l!==undefined?l.length:0
+${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t, s)}}`
+  }
+  return `${decl ? `let ${t}n=false,${t}raw=0,${t}tl=0,${t}lv=0,${t}lg=0,${t}rt=0${sinkSlots(t, s)}\n` : `${t}n=false\n`}{const b=ctx._cstBuf
+if(b!==undefined){
+const r=b.raw;${t}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${t}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${t}tl=l!==undefined?l.length:0
+${t}n=true
+}else if(ctx._cstLeaves!==undefined||ctx._cstRawChildren!==undefined||ctx._cstTriviaLog!==undefined||ctx._fields!==undefined||ctx._errors!==undefined||ctx._triviaLog!==undefined||ctx._rootTriviaLog!==undefined){
+${t}raw=ctx._cstRawChildren!==undefined?ctx._cstRawChildren.length:0
+${t}tl=ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0
+${t}lv=ctx._cstLeaves!==undefined?ctx._cstLeaves.length:0
+${t}n=true
+}
+if(${t}n){
+${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t, s)}
+}}`
+}
+
+/**
+ * The matching rollback for a mark emitted with prefix `t`.
+ *
+ * THE `_fields` AND `_errors` MARKS ARE NOT TAKEN, because in an EMITTED
+ * assembly neither sink can grow. `OP_FIELD` is the only writer of `_fields`
+ * and `OP_EXPECT`/`recoverScan` the only writers of `_errors`, and none of the
+ * three is lowered by this file — a table containing one raises `Unemittable`
+ * and the WHOLE assembly falls back to `assemble.ts`'s closures, so no emitted
+ * body ever runs beside one. That is what makes this an emit-time fact rather
+ * than a per-parse guess, and it is why `assemble.ts`'s `nextTerm` still takes
+ * all seven: it is the engine those constructs actually run in.
+ *
+ * The two sinks are passed differently because `rollbackCstCaptureAt` guards
+ * them differently. `_errors` is guarded on `errors !== undefined`, so
+ * `undefined` is its established "no mark taken" sentinel and is correct even
+ * for a caller-supplied context that arrived with errors already on it.
+ * `_fields` has no such guard — `length = undefined` would throw — so it takes
+ * the literal `0` that a per-node `_fields` no `OP_FIELD` can push to always has.
+ */
+function emitRollback(t: string, buf: boolean, s: Sinks = NO_SINKS): string {
+  // `_rbBuf` is the `_cstBuf` arm of `rollbackCstCaptureAt` plus the two trivia
+  // truncations, with the sink discrimination the label already answered removed.
+  // It takes no piece, so the header's sharing rule admits it.
+  //
+  // The two side sinks stay OUT of `_rbBuf` rather than growing its parameter
+  // list: they are absent from most tables, and a fixed seven-argument helper
+  // would make every grammar pay the two extra pushes to serve the ones that
+  // carry a field. Guarded exactly as `rollbackCstCaptureAt:242,233` guards them
+  // — `_errors` on a defined mark, because `undefined` is its "no mark taken"
+  // sentinel, and `_fields` on the array alone.
+  const fd = s.fd ? `\nif(ctx._fields!==undefined&&ctx._fields.length!==${t}fd)ctx._fields.length=${t}fd` : ''
+  const er = s.er ? `\nif(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}er` : ''
+  if (buf) return `_rbBuf(ctx,${t}raw,${t}tl,${t}lv,${t}lg,${t}rt)${fd}${er}`
+  if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,0,undefined,${t}lg,${t}rt)`
+  return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : '0'},${s.er ? `${t}er` : 'undefined'},${t}lg,${t}rt)}`
+}
+
+/**
+ * ONE SEQUENCE TERM — `assemble.ts`'s `nextTerm`, inlined at the site.
+ *
+ * Reads and writes `cur`; the term's value lands in `dst`; failure returns
+ * `FAIL` directly, because emitted here there is no shared return channel to
+ * encode a −1 sentinel into.
+ *
+ * The `ctx.trivia === undefined` test is GONE wherever the site label answers
+ * it. It was never an option — `OP_SCOPE` swaps `ctx.trivia` mid-parse, which is
+ * why it could not be lifted into `RunCfg` — but it IS a property of where the
+ * term sits, and `site-labels.ts` resolves it at encode time. `TRI_NONE` keeps
+ * only the first branch, a known slot keeps only the second (with the scope's own
+ * scanner already bound into `skip`), and `TRI_UNKNOWN` keeps both.
+ */
+function emitTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string, s: Sinks): string {
+  const fast = `const ${t}v=${callee}(input,cur,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+cur=EC.e`
+  if (l.tri === TRI_NONE) return fast
+  const scanned = `${emitMark(t, l.buf, s)}
+const ${t}s=${skip}(input,cur,ctx)
+const ${t}v=${callee}(input,${t}s,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+if(EC.e>${t}s)cur=EC.e
+else{${emitRollback(t, l.buf, s)}}`
+  if (l.tri !== TRI_UNKNOWN) return scanned
+  return `if(ctx.trivia===undefined){
+${fast}
+}else{
+${scanned}
+}`
+}
+
+/**
+ * The repetition's LEAD-TRIVIA skip, as a BLOCK.
+ *
+ * A block and not a bare statement because the separator form spells it
+ * `} else <this>`, and a label that erases the skip entirely would otherwise
+ * leave a dangling `else` to swallow the statement after it.
+ */
+function leadSkip(hasTrivia: string, leadTrivia: string, skip: string): string {
+  if (hasTrivia === 'false') return '{}'
+  const call = `itemStart=${skip}(input,itemStart,ctx)`
+  if (hasTrivia === 'true') return leadTrivia === 'true' ? `{${call}}` : `{if(${leadTrivia})${call}}`
+  return `{if(hasTrivia&&${leadTrivia})${call}}`
+}
+
+/**
+ * THE THREE POOLS, SAID AS INDICES INTO THE PROGRAM.
+ *
+ * The pools themselves are `Uint32Array`s, `{ascii, hi}` class objects and
+ * string arrays — printable, but at 129 words per mask and 128 bytes per class
+ * they would dwarf the table they belong to. Every entry is already IN the
+ * program: a class is `cc[i]`, an arm's expected set is `fx[i]`, and a mask is a
+ * pure function of its class row. So the plan is three arrays of small integers,
+ * and `rebuildPools` turns it back into the pools with allocation only — no
+ * string building, and in particular no `Function` constructor.
+ *
+ * This is what lets the macro pre-compile an assembly: the FACTORY is printed as
+ * a real function literal, and its data arguments are rebuilt from this.
+ */
+export type PoolPlan = {
+  /** Per `CLS` row: the `cc` index of each entry, `-1` for a null (ungated) arm. */
+  readonly classes: readonly (readonly number[])[]
+  /** Per `AFX` row: the `fx` index of each arm's expected set. */
+  readonly armExpected: readonly (readonly number[])[]
+  /** Per `MASK` row: the `CLS` index the mask is computed from. */
+  readonly masks: readonly number[]
+}
+
+/** Everything the compiled factory needs bound, beside the emitted text. */
+export type EmitResult = {
+  readonly source: string
+  /** Site offsets the emitter reached — the emitted twin of `Assembly.reached`. */
+  readonly reached: ReadonlySet<number>
+  /** Hoisted per-choice candidate masks, in `MASK` order. */
+  readonly masks: readonly Uint32Array[]
+  /** Hoisted per-arm class gates, in `CLS` order. */
+  readonly classes: readonly (ResolvedClass | null)[][]
+  /** Hoisted per-arm expected sets, in `AFX` order. */
+  readonly armExpected: readonly (readonly string[])[][]
+  /** The same three pools as indices, for a build-time emitter. */
+  readonly plan: PoolPlan
+}
+
+/** The candidate mask for one `CLS` row — the ONE definition, shared with the emitter. */
+function maskForClassRow(gates: readonly (ResolvedClass | null)[]): Uint32Array {
+  const m = new Uint32Array(129)
+  for (let i = 0; i < gates.length; i++) {
+    const cls = gates[i]!
+    const bit = 1 << i
+    if (cls === null) { for (let c = 0; c < 129; c++) m[c]! |= bit; continue }
+    for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) m[c]! |= bit
+  }
+  return m
+}
+
+/**
+ * Rebuild the three pools a pre-compiled factory takes, from the resolved table
+ * and the plan the emitter printed. Allocation only.
+ */
+export function rebuildPools(
+  cc: readonly ResolvedClass[],
+  fx: readonly (readonly string[])[],
+  plan: PoolPlan,
+): { masks: Uint32Array[]; classes: (ResolvedClass | null)[][]; armExpected: (readonly string[])[][] } {
+  const classes = plan.classes.map(row => row.map(i => (i < 0 ? null : cc[i] ?? null)))
+  return {
+    classes,
+    armExpected: plan.armExpected.map(row => row.map(i => fx[i] ?? [])),
+    masks: plan.masks.map(ci => maskForClassRow(classes[ci]!)),
+  }
+}
+
+/**
+ * Emit the whole assembly for one resolved table and one option set.
+ *
+ * Throws `Unemittable` for any construct not lowered. It does NOT compile the
+ * text — `assemble.ts` does — so a refusal and a compile failure stay two
+ * distinguishable outcomes at the call site.
+ */
+export function emitAssemblySource(
+  t: ResolvedTable,
+  prog: TableProgram,
+  cfg: {
+    hostCst: boolean
+    hostReadsChildren?: boolean
+    hostCaptureTrivia?: ((type: string) => boolean) | undefined
+    trackLines: boolean
+    tolerant: boolean
+    coverage: boolean
+    probe: boolean
+  },
+  extraIps: readonly number[] = [],
+): EmitResult {
+  const { code, k, disp, dsp, triviaLabelled } = t
+  const swapLegal = !cfg.trackLines
+  const hostCst = cfg.hostCst
+
+  /**
+   * RECOVERY IS EMITTED, and the refusal this replaces was wrong in SCOPE.
+   *
+   * The refusal read: *"`recoverScan`'s protocol has three implementations
+   * already and a fourth is how an error span drifts... It is also cold by
+   * construction — reached only on the failure of an element — so the speed
+   * argument for emitting it is absent."*
+   *
+   * The drift half is answered by construction, not by argument: NOTHING of the
+   * protocol is reimplemented here. `recoverScan`, `matchesAt`, `orSentinel` and
+   * `captureError` are BOUND and CALLED, exactly as the closure engine calls
+   * them, so there is no fourth implementation to drift — the same reason
+   * `OP_SCAN` may bind an interpreted combinator and index it (`SCANS[i]`).
+   *
+   * The cold half was true of recovery and FALSE of the refusal. This throw sat
+   * at the top of the emitter, so it did not decline the cold recovery rows — it
+   * declined THE ENTIRE ASSEMBLY. Every tolerant parse in the product therefore
+   * ran the array-indexed closure walk for its whole hot path: every literal,
+   * every choice, every repetition, none of which is recovery and all of which is
+   * as hot as the strict path that is emitted. The speed argument is absent for
+   * `recoverScan` and was never absent for the table around it.
+   *
+   * What stays interpreted is what was already interpreted for the strict path.
+   */
+  const REC = prog.rec === 1 && cfg.tolerant
+  if (cfg.coverage) throw new Unemittable('a coverage assembly')
+
+  // THE DOWNWARD PASS, BEFORE ANY LOWERING. The roots are exactly the sites
+  // `link` is called on from outside a body — the rule entries and the scan
+  // pool's `extraIps` — and each starts at `TOP`, because a caller outside the
+  // emitted scope supplies a context this pass cannot see.
+  const roots = [...Object.values(prog.rules), ...extraIps]
+  const labels = computeSiteLabels(code, roots, hostCst)
+
+  // THE SIDE-SINK CENSUS, over the same reachable set the labels are computed
+  // from. `OP_FIELD` is the only ROW that writes `_fields` and `OP_EXPECT` the
+  // only emittable row that writes `_errors` — `recoverScan` is the other, and a
+  // recovery assembly is refused above. A table with neither pays for neither.
+  //
+  // `OP_SCAN` RAISES BOTH, and that is not caution — it is a measured defect.
+  // The row runs an INTERPRETED combinator (`scanTo`/`balanced`, rebuilt by
+  // `resolveTable`'s pool from subtrees), so its interior is not in this code
+  // array and this walk cannot see what it writes. `balanced()`'s unclosed-group
+  // failure pushes a `parseError` carrying its closer, and less's `at-rules.less`
+  // and `css-3.less` each left several of them on `RunResult.errors` — errors
+  // that the CLOSURE engine rolls back, because its mark covers `_errors`
+  // unconditionally. The two engines disagreed on the errors facet of a parse
+  // that otherwise matched byte for byte.
+  //
+  // Any future row whose child is not an offset in `code` belongs here for the
+  // same reason. `OP_LIVE` is the other such row, and it is unemittable.
+  const sinks: Sinks = (() => {
+    let fd = false
+    // A RECOVERY ASSEMBLY IS AN `_errors` WRITER EVERYWHERE. `recoverScan` pushes
+    // through `captureError` from inside any `OP_REP` that recovers, and the
+    // recovering row is the repetition itself rather than a distinguishable
+    // opcode — so there is no site to census and the answer is the assembly's.
+    //
+    // This is the `OP_SCAN` lesson applied before it costs anything rather than
+    // after: that row raised both sinks because its interior is not in `code`,
+    // and the defect it was raised for was precisely an `_errors` rollback the
+    // two engines disagreed on while matching byte for byte on the tree.
+    let er = REC
+    for (const ip of reachableSites(code, roots)) {
+      const op = code[ip]
+      if (op === OP_SCAN) { fd = true; er = true; break }
+      if (op === OP_FIELD) fd = true
+      else if (op === OP_EXPECT) er = true
+    }
+    return { fd, er }
+  })()
+
+  const bodies: string[] = []
+  const byIp = new Map<number, string>()
+  const reached = new Set<number>()
+  const prelude: string[] = []
+  const skipDefs: string[] = []
+  const skipPool = new Map<string, string>()
+  const pool = new Map<string, string>()
+  const masks: Uint32Array[] = []
+  const classes: (ResolvedClass | null)[][] = []
+  const armExpected: (readonly string[])[][] = []
+  /**
+   * THE POOLS, SAID AS INDICES — see `PoolPlan`. Written in lockstep with the
+   * three arrays above so a build-time emitter can print the plan instead of the
+   * pools, and `rebuildPools` can reproduce them from the resolved table alone.
+   * Kept adjacent to each `push` for exactly the reason `EMITTED_PARAMS` is one
+   * list: two orders that must agree cannot be allowed to live apart.
+   */
+  const classPlan: number[][] = []
+  const armExpectedPlan: number[][] = []
+  const maskPlan: number[] = []
+
+  /** `codegen.ts`'s hoisted pools, same spelling: `_k<N>` / `_fx<N>` / `_fn<N>`. */
+  function hoist(kind: string, expr: string): string {
+    const hit = pool.get(expr)
+    if (hit !== undefined) return hit
+    const nm = `_${kind}${pool.size}`
+    pool.set(expr, nm)
+    prelude.push(`const ${nm}=${expr}`)
+    return nm
+  }
+  const kRef = (i: number): string => hoist('k', `K[${i}]`)
+  const fxRef = (i: number): string => hoist('fx', `FX[${i}]`)
+  const fnRef = (i: number): string => hoist('fn', `FNS[${i}]`)
+  /**
+   * The sync sentinel for a char-class index, hoisted once per class.
+   *
+   * −1 is "no usable sentinel" — the same answer `firstSetSentinel` gives for an
+   * `any`/`empty` first set — and it lowers to the literal `undefined` so the
+   * publish below collapses to the inherited sentinel with no array read.
+   */
+  const sentRef = (cls: number): string => cls < 0 ? 'undefined' : hoist('sent', `SENTS[${cls}]`)
+
+  /** A fresh local prefix, so two inlined marks in one body cannot collide. */
+  let uid = 0
+  const tmp = (): string => `_t${uid++}_`
+
+  /**
+   * THE TRIVIA SCAN FOR ONE SITE LABEL.
+   *
+   * `_skipTrivia` answers four questions on every call — is a scanner installed,
+   * is the global trivia log live, is capture on, is a capture sink open — and
+   * three of them are what the label already knows. This mints the arm that
+   * survives, once per distinct label, and every site with that label calls it by
+   * name.
+   *
+   * Shared, and the header's rule is why it may be: none of these takes a PIECE.
+   * The installed scanner arrives as a hoisted `TRIVIASCAN[ki]` const, not as an
+   * argument, so a second caller cannot pollute a call site's feedback. That is
+   * the same test `_skipTrivia` passed and `nextTerm` failed.
+   *
+   * `_triviaLog` is deliberately NOT resolved here. It is neither an option nor a
+   * site property — nothing in `src` writes it except a caller-supplied
+   * `ParseContext` (`types.ts:524`) — so it stays the one runtime read.
+   */
+  function skipFor(l: SiteLabel): string {
+    if (l.tri < 0) return '_skipTrivia'
+    const ki = l.tri
+    // `TRIVIASCAN[ki]` IS NULLABLE. `program.ts:475` maps every trivia through
+    // `fastTriviaScanner`, which declines any shape it cannot lower, so the slot
+    // holds `null` for those — which is why `OP_SCOPE` installs a scanner it
+    // still has to null-test. The presence of a lowering is table data like the
+    // label bit beside it, so it belongs in the key rather than in a branch.
+    const hasScan = swapLegal && !triviaLabelled[ki]! && t.triviaScan[ki] != null
+    const key = `${ki}|${hasScan ? 1 : 0}|${l.buf ? 1 : 0}|${l.cap}`
+    const hit = skipPool.get(key)
+    if (hit !== undefined) return hit
+    const nm = `_sk${skipPool.size}`
+    skipPool.set(key, nm)
+    if (!hasScan) {
+      // No installed scanner: the labelled/`trackLines` path, which records
+      // through `scanTrivia`. `needsDeferredTriviaCommit` is implied by an open
+      // buffer, so an in-node site skips the call that asks.
+      skipDefs.push(l.buf
+        ? `function ${nm}(input,cur,ctx){const s=scanTrivia(input,cur,ctx);s.commit();return s.end}`
+        : `function ${nm}(input,cur,ctx){
+if(needsDeferredTriviaCommit(ctx)){const s=scanTrivia(input,cur,ctx);s.commit();return s.end}
+return advanceTrivia(input,cur,ctx)}`)
+      return nm
+    }
+    const sc = hoist('ts', `TRIVIASCAN[${ki}]`)
+    // `ctx.captureTrivia === true && (a sink is open)`, with both conjuncts
+    // resolved as far as the label takes them.
+    const sink = l.buf ? 'true' : '(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)'
+    const capturing = l.cap === CAP_OFF ? 'false' : l.cap === CAP_ON ? sink : `(ctx.captureTrivia===true&&${sink})`
+    if (capturing === 'true') {
+      // Capture is on and a sink is open: the bare-scanner arm is unreachable.
+      skipDefs.push(`function ${nm}(input,cur,ctx){return skipTriviaScanned(${sc},input,cur,ctx)}`)
+      return nm
+    }
+    const guard = capturing === 'false'
+      ? 'ctx._triviaLog===undefined'
+      : `ctx._triviaLog===undefined&&!${capturing}`
+    skipDefs.push(`function ${nm}(input,cur,ctx){
+if(${guard})return ${sc}(input,cur)
+return skipTriviaScanned(${sc},input,cur,ctx)}`)
+    return nm
+  }
+
+  /**
+   * The BODY OF A LOWERED REGEX ROW, or `undefined` when the shape declines.
+   *
+   * Declining is the safe direction and the only one this can take: a shape it
+   * fails to recognise falls through to the regex, which is what the row did
+   * before. A shape it recognises WRONGLY is a defect, and the gate for that is
+   * `bench/scan-shape-oracle.ts` — every regex constant of every workload
+   * grammar driven at every position of its own corpus against the sticky
+   * `exec` it replaces, end for end.
+   *
+   * The value is `input.slice(pos, end)`, which for a STICKY regex is `m[0]`
+   * character for character. The `u`/`i`/`m`/`s` flags are handled inside
+   * `scanShapeFromRegex`; `u` declines outright, because a code-unit scan is not
+   * a code-point one.
+   *
+   * `captureLeaf` is the SITE'S — it arrives from `lower`, already resolved
+   * against that site's label, so a lowered row pushes its leaf through exactly
+   * the form `OP_LIT` and `OP_LIT_CI` push theirs. Re-deriving the capture test
+   * here would put a second answer to a settled question inside the one body
+   * that runs most.
+   */
+  function emitScan(
+    ki: number,
+    xf: string,
+    track: boolean,
+    captureLeaf: (value: string) => string,
+  ): string | undefined {
+    const re = k[ki]
+    if (!(re instanceof RegExp)) return undefined
+    const shape = scanShapeFromRegex(re.source, re.flags)
+    if (shape === null) return undefined
+    let n = 0
+    const p = tmp()
+    const m = emitShapeMatch(shape, 'pos', (prefix = '_v') => `${p}${prefix}${n++}`, '')
+    return `
+${m.setup.join('\n')}
+if(${m.ok}){
+const e=${m.end}
+const v=input.slice(pos,e)
+${captureLeaf('v')}
+${track ? '_trackLines(ctx,input,e)\n' : ''}EC.e=e
+return v
+}
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
+`
+  }
+
+  function link(ip: number): string {
+    const hit = byIp.get(ip)
+    if (hit !== undefined) return hit
+    // An ALIAS site forwards to its child with no body of its own. Resolved
+    // before reservation so no name is minted for a function that would only
+    // add a call frame — `assemble.ts` makes the same choice by returning the
+    // child piece itself.
+    const target = resolveAlias(ip)
+    const done = byIp.get(target)
+    if (done !== undefined) return done
+    const fname = `_pf${target}`
+    // Reserved BEFORE lowering, so a back-edge into a site still in flight binds
+    // to the hoisted declaration rather than to a forwarding stub. This is the
+    // whole of `assemble.ts`'s `inFlight` map and its one shared closure.
+    byIp.set(target, fname)
+    bodies.push(lower(target, fname))
+    return fname
+  }
+
+  /**
+   * FOLLOW THE ALIAS CHAIN TO THE FIRST SITE WITH A BODY — iteratively, and
+   * BEFORE anything is reserved.
+   *
+   * The previous form recursed through `link` and parked a PROVISIONAL name
+   * `_pf<ip>` in the alias map so that a cycle would terminate. It terminated,
+   * and it emitted a call to a function that does not exist: `OP_RULE` is the
+   * only back-edge in a table, `OP_RULE` is an alias, so a recursive rule whose
+   * cycle re-enters through the alias row still in flight bound to the
+   * provisional name, and every grammar with that shape compiled to
+   * `_pf1100 is not defined` — a ReferenceError at parse time, from a body that
+   * the `new Function` call above accepts as syntactically valid.
+   *
+   * Resolving the chain first removes the window: no name is ever handed out for
+   * a site that will not get a body, because the only name handed out is the
+   * CHAIN'S END, which is always lowered.
+   *
+   * A cycle of alias-only rows — `A` aliasing to `B` aliasing back to `A`, with
+   * no body anywhere in between — is a rule that expands to itself and consumes
+   * nothing. Refused BY NAME rather than looped on: it is a defect in the
+   * grammar, and the closure engine meets it as a stack overflow at parse time.
+   */
+  function resolveAlias(ip: number): number {
+    let cur = ip
+    let seen: Set<number> | undefined
+    for (;;) {
+      reached.add(cur)
+      const next = aliasOf(cur)
+      if (next === undefined) return cur
+      if (seen === undefined) seen = new Set([cur])
+      else if (seen.has(cur)) throw new Unemittable('a cycle of alias-only sites (a rule that expands to itself)')
+      else seen.add(cur)
+      cur = next
+    }
+  }
+
+  /** Sites that forward to a child with no body, decided by option, data, or LABEL. */
+  function aliasOf(ip: number): number | undefined {
+    const op = code[ip]
+    // `OP_GATE` under a probe or a tolerant recovery is a no-op that forwards to
+    // its child, exactly as `assemble.ts:952` resolves it.
+    if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2]!
+    if (op === OP_RULE) return code[ip + 1]!
+    // A SCOPE THAT INSTALLS WHAT IS ALREADY INSTALLED. `encode.ts:520` wraps
+    // EVERY rule of a `rules({ trivia }, …)` map in its own `OP_SCOPE`, so a
+    // grammar with one ambient trivia re-installs the same slot at every rule
+    // entry — six context stores, a scanner swap and their six restores, per
+    // call, to arrive at the values already there.
+    //
+    // The label is what makes this decidable: `tri >= 0` can ONLY have come from
+    // an enclosing `OP_SCOPE` carrying that slot, and that scope set
+    // `ctx.triviaKindLabels` and `_pfScan` from the same slot, so all three are
+    // already the values this row would write. Restricted to plain `OP_SCOPE`
+    // with no root-capture policy: `OP_SCOPE_CAP` also raises `captureTrivia`,
+    // and the two flag bits are a real refusal and a real save/restore.
+    //
+    // `ki >= 0` is required rather than implied: `TRI_NONE` and `TRI_UNKNOWN` are
+    // themselves negative, so comparing a negative operand against a lattice
+    // element would read "unknown" as a match.
+    if (op === OP_SCOPE && code[ip + 3]! === 0 && code[ip + 1]! >= 0
+      && labels.at(ip).tri === code[ip + 1]!) {
+      return code[ip + 2]!
+    }
+    return undefined
+  }
+
+  function lower(ip: number, fname: string): string {
+    const op = code[ip]
+    const head = `function ${fname}(input,pos,ctx){`
+    const L = labels.at(ip)
+    /**
+     * THE LEAF CAPTURE TEST, and only the test.
+     *
+     * `cstCaptureActive` is `_cstBuf !== undefined || _cstLeaves !== undefined`,
+     * and `OP_NODE` opens `_cstBuf` on entry regardless of host mode — so under a
+     * node the answer is a constant `true`. What that licenses is dropping the
+     * CALL, never the capture: the captured leaves feed `kids` → `build(...)`,
+     * and eliding them on `hostCst === false` would be a wrong tree, not a fast
+     * one. Off-label the test is INLINED rather than called, which is sound
+     * everywhere and costs nothing.
+     *
+     * THE PUSH ITSELF is two cross-module calls — `pushCstLeaf` to decide on
+     * `trackLines`, then `pushCstChild` to decide which collector is live — on
+     * the most-executed path there is. Both decisions are settled here:
+     * `trackLines` is `RunCfg`, and an open `_cstBuf` is the label. `_pushLeafBuf`
+     * is that pair with both branches taken, and it takes no piece.
+     */
+    const pushLeaf = L.buf && !cfg.trackLines ? '_pushLeafBuf' : '_pushLeaf'
+    const captureLeaf = (value: string): string => {
+      const call = `${pushLeaf}(ctx,${value},pos,e)`
+      return L.buf ? call : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${call}`
+    }
+    switch (op) {
+      case OP_LIT:
+      case OP_LIT_TRACK: {
+        const s = k[code[ip + 1]!] as string
+        const xf = fxRef(code[ip + 2]!)
+        const track = op === OP_LIT_TRACK
+        // LENGTH IS TABLE DATA, so the compare is chosen here — the emitted twin
+        // of the closure engine's length-keyed literal bodies.
+        const test = s.length === 1
+          ? `input.charCodeAt(pos)===${s.charCodeAt(0)}`
+          : s.length === 2
+            ? `input.charCodeAt(pos)===${s.charCodeAt(0)}&&input.charCodeAt(pos+1)===${s.charCodeAt(1)}`
+            : `input.startsWith(${q(s)},pos)`
+        return `${head}
+if(${test}){
+const e=pos+${s.length}
+${captureLeaf(q(s))}
+${track ? '_trackLines(ctx,input,e)\n' : ''}EC.e=e
+return ${q(s)}
+}
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
+}`
+      }
+
+      case OP_LIT_CI:
+      case OP_LIT_CI_TRACK: {
+        const s = k[code[ip + 1]!] as string
+        const xf = fxRef(code[ip + 2]!)
+        const track = op === OP_LIT_CI_TRACK
+        // THE FOLD, UNROLLED AGAINST CONSTANTS.
+        //
+        // `assemble.ts:866-873` holds the folded literal in an ARRAY and walks it
+        // with a loop and a ternary per character — a load, a bounds check and a
+        // branch for a comparison whose right-hand side is known here. Emitted, the
+        // literal is not data at all: each character is one or two compares
+        // against integers, straight-line, no array and no closure.
+        //
+        // Semantics are `asciiFoldEq`'s exactly. `foldedLit[i]` is the literal
+        // folded, so it is never in A-Z; and `fold` maps A-Z INTO a-z and is the
+        // identity everywhere else. So for a folded character `c`:
+        //   - `c` in a-z  — the input matches iff it is `c` or `c - 32`
+        //   - otherwise   — the input matches iff it is exactly `c`, because the
+        //                   only characters fold moves land in a-z
+        // Past end of input `charCodeAt` is NaN, which compares unequal to both —
+        // the same answer the length test gave.
+        //
+        // The match VALUE is `input.slice(pos, e)`, the INPUT's casing and not the
+        // literal's, exactly as `literal.ts:86` has it — returning the literal
+        // would silently normalise case in any node built from it.
+        const tests: string[] = []
+        const reads: string[] = []
+        for (let i = 0; i < s.length; i++) {
+          const raw = s.charCodeAt(i)
+          const f = raw >= 65 && raw <= 90 ? raw + 32 : raw
+          const at = i === 0 ? 'pos' : `pos+${i}`
+          if (f >= 97 && f <= 122) {
+            reads.push(`const c${i}=input.charCodeAt(${at})`)
+            tests.push(`(c${i}===${f}||c${i}===${f - 32})`)
+          } else {
+            tests.push(`input.charCodeAt(${at})===${f}`)
+          }
+        }
+        return `${head}
+${reads.length > 0 ? `${reads.join('\n')}\n` : ''}if(${tests.join('&&')}){
+const e=pos+${s.length}
+const v=input.slice(pos,e)
+${captureLeaf('v')}
+${track ? '_trackLines(ctx,input,e)\n' : ''}EC.e=e
+return v
+}
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
+}`
+      }
+
+      case OP_RX:
+      case OP_RX_TRACK: {
+        const xf = fxRef(code[ip + 2]!)
+        const track = op === OP_RX_TRACK
+        // THE MATCH ARRAY IS THE COST, not the matching. `re.exec` allocates one
+        // per row — 6,005 rows per `json/document` parse, 12.9% of everything
+        // executed — and every field of it but `[0]` is discarded here. A shape
+        // that lowers replaces the call with a straight-line scan over
+        // `charCodeAt`, and the ranges are FOLDED INTO THE SOURCE by
+        // `classCond`/`litCond`/`foldEq` rather than read from a table at run
+        // time: emitted as a static body consulting `inRanges`, this would
+        // reproduce the per-character loop it exists to remove.
+        const scanned = emitScan(code[ip + 1]!, xf, track, captureLeaf)
+        if (scanned !== undefined) return `${head}${scanned}}`
+        // STICKINESS IS THE PRECONDITION OF BOTH FORMS BELOW, and it is checked
+        // rather than assumed. `encode.ts:588` appends `y` to every regex row it
+        // emits, so a non-sticky constant here would be a new encoder path — and
+        // `lastIndex=pos` would already have been meaningless for it, silently
+        // matching from wherever the last row left off.
+        const rxk = k[code[ip + 1]!]
+        if (!(rxk instanceof RegExp) || !rxk.sticky) throw new Unemittable('a non-sticky regex row')
+        // A ROW THAT DOES NOT LOWER STILL NEED NOT ALLOCATE. `test` and `exec`
+        // run the identical match; `exec` additionally materialises a
+        // JSRegExpResult, and V8's `test` fast path does not. For a STICKY
+        // regex `lastIndex` IS the match end on success (RegExpBuiltinExec
+        // step 15), so `input.slice(pos, lastIndex)` is `m[0]` character for
+        // character, and the array was the only thing dropped. Counted, not
+        // reasoned: 400×~2k sticky matches of json's unlowered string body take
+        // 99 scavenges through `exec` and 10 through `test`, reproduced.
+        const re = kRef(code[ip + 1]!)
+        return `${head}
+${re}.lastIndex=pos
+if(${re}.test(input)){
+const e=${re}.lastIndex
+const v=input.slice(pos,e)
+${captureLeaf('v')}
+${track ? '_trackLines(ctx,input,e)\n' : ''}EC.e=e
+return v
+}
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
+}`
+      }
+
+      case OP_EMPTY:
+        // `''`, not `null` — the zero-width match's value. The other three engines
+        // (exec.ts, exec-baseline.ts, assemble.ts) all return `''`; this one returned
+        // `null`, so the SAME program yielded a different `value` depending only on
+        // which engine ran. Unreached from the combinator API today — `OP_EMPTY` is
+        // emitted only as `finish()` padding for an EMPTY rule map, which then has no
+        // walk roots for the emitter to visit — but that is an accident of two
+        // unguarded facts, not an invariant, and it is already reachable through the
+        // hand-built-program idiom this file's driver tests use.
+        return `${head}EC.e=pos;return ''}`
+
+      case OP_GATE: {
+        const child = link(code[ip + 2]!)
+        const ci = classes.push([t.cc[code[ip + 1]!]!]) - 1
+        classPlan.push([code[ip + 1]!])
+        const cls = hoist('cl', `CLS[${ci}][0]`)
+        const xf = fxRef(code[ip + 3]!)
+        return `${head}
+if(!classHas(${cls},lead(input,pos))){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`
+      }
+
+      case OP_XFORM: {
+        const fn = fnRef(code[ip + 1]!)
+        const child = link(code[ip + 2]!)
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+return ${fn}(v,{start:pos,end:EC.e})
+}`
+      }
+
+      case OP_LABEL: {
+        const child = link(code[ip + 1]!)
+        const xf = fxRef(code[ip + 2]!)
+        // `_fe` IS NOT TOUCHED — `map.ts:84` keeps the child's span and replaces
+        // only the expected set. A label that moved the failure position would
+        // report the diagnostic at the label's start rather than where the input
+        // actually stopped.
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)ctx._fx=${xf}
+return v
+}`
+      }
+
+      case OP_FIELD: {
+        const name = q(k[code[ip + 1]!] as string)
+        const child = link(code[ip + 2]!)
+        // `ctx._fields?.push(…)` — conditional on a field-reading node being
+        // open, exactly as `map.ts` has it, so a field outside one costs a load
+        // and a branch. The ARRAY is what `OP_NODE` hands to `buildFieldMap`.
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+const f=ctx._fields
+if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
+return v
+}`
+      }
+
+      case OP_EXPECT: {
+        const child = link(code[ip + 1]!)
+        const xf = fxRef(code[ip + 2]!)
+        // TWO ARMS, mirroring `assemble.ts:1050`. A TOLERANT `expect()` EMBEDS
+        // ITS ERROR IN THE TREE and not only in the flat `_errors` side-channel
+        // (`combinators/expect.ts:150`, codegen's `_ctx._rec.capture` at
+        // codegen.ts:4470) — so a tree walk finds every diagnostic and the node
+        // survives incremental subtree reuse. `captureError` is the shared
+        // function, called; the embedding is not restated here.
+        //
+        // `_fc` IS CLEARED IN BOTH: a recovered failure is no longer a failure,
+        // and the commit bit the child raised must not survive it and cut an
+        // enclosing choice (`assemble.ts:1058-1066`).
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v!==FAIL)return v
+const err={_tag:'parseError',span:${prog.lines === 1 ? 'spanLines(ctx,pos,pos)' : '{start:pos,end:pos}'},expected:${xf}}
+const es=ctx._errors
+if(es!==undefined)es.push(err)
+${REC ? 'if(ctx._tolerant===true)captureError(ctx,err)\n' : ''}ctx._fc=false
+EC.e=pos
+return err
+}`
+      }
+
+      case OP_ROUTED: {
+        const fb = code[ip + 1]!
+        const fallback = fb >= 0 ? link(fb) : undefined
+        // The SPAN is the routed item's own object, not a copy — `assemble.ts`
+        // hands the same one to the leaf, and a fresh `{start,end}` here would
+        // be a different tree for any consumer comparing by identity.
+        const push = `pushCstLeaf(ctx,{_tag:'leaf',value:it.value,span:it.span})`
+        return `${head}
+const it=ctx._routed
+if(it===undefined||pos!==it.span.start){
+${fallback !== undefined ? `return ${fallback}(input,pos,ctx)` : 'ctx._fe=pos;ctx._fx=ROUTED_FX;return FAIL'}
+}
+${L.buf ? push : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${push}`}
+EC.e=it.span.end
+return it.value
+}`
+      }
+
+      case OP_SCAN: {
+        const si = code[ip + 1]!
+        // The scan pool is built FROM subtrees, so it is populated after this
+        // text compiles. The array is passed by reference and indexed on
+        // execution, which is what the closure engine's lazy bind amounts to.
+        return `${head}
+const r=SCANS[${si}].parse(input,pos,ctx)
+if(!r.ok){ctx._fe=r.span.start;ctx._fx=r.expected??EMPTY_FX;return FAIL}
+EC.e=r.span.end
+return r.value
+}`
+      }
+
+      case OP_SCOPE:
+      case OP_SCOPE_CAP: {
+        const ki = code[ip + 1]!
+        const cap = op === OP_SCOPE_CAP
+        const flags = code[ip + 3]!
+        const child = link(code[ip + 2]!)
+        // THE SWAP, RESOLVED AT EMIT. `swapLegal` is `!trackLines`, an option;
+        // the other two are table data. All three are known here, so the body
+        // holds the scanner it installs as a hoisted const.
+        const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki]! ? hoist('ts', `TRIVIASCAN[${ki}]`) : 'null'
+        const tri = ki < 0 ? 'undefined' : hoist('tv', `TRIVIA[${ki}]`)
+        const lab = ki < 0 ? 'undefined' : hoist('tl', `TRIVIA[${ki}]._meta.triviaKindLabels`)
+        // The two root-capture policies are TABLE DATA, so they are emitted INTO
+        // the body. `scopeRootPolicy`'s two wrapper closures and their two extra
+        // call frames do not exist here.
+        const strict = (flags & 2) !== 0 ? 'refuseUnclassifiedRootScope(ctx._rootTriviaStrictScopes)\n' : ''
+        const rootCap = (flags & 1) !== 0
+        return `${head}
+${strict}${rootCap ? 'const sR=ctx._rootTriviaCapture\nctx._rootTriviaCapture=false\n' : ''}const sT=ctx.trivia,sL=ctx.triviaKindLabels,sS=_pfScan${cap ? ',sC=ctx.captureTrivia' : ''}
+_pfScan=${scanFor}
+ctx.trivia=${tri}
+ctx.triviaKindLabels=${lab}
+${cap ? 'ctx.captureTrivia=true\n' : ''}const v=${child}(input,pos,ctx)
+${cap ? 'ctx.captureTrivia=sC\n' : ''}ctx.trivia=sT
+ctx.triviaKindLabels=sL
+_pfScan=sS
+${rootCap ? 'ctx._rootTriviaCapture=sR\n' : ''}return v
+}`
+      }
+
+      /* ── boundaries ──────────────────────────────────────────────────────── */
+
+      case OP_TOKEN:
+      case OP_LEAF: {
+        const isToken = op === OP_TOKEN
+        const fn = isToken ? undefined : fnRef(code[ip + 1]!)
+        const child = link(isToken ? code[ip + 1]! : code[ip + 2]!)
+        // `try`/`finally`, AS `assemble.ts` HAS IT. `OP_SCOPE` restores linearly
+        // and this does not, and the difference is not an oversight in either:
+        // `test/unit/token.test.ts:198` pins CONTEXT RESTORATION ON A THROWING
+        // BODY across the interpreter and `compile`, and jess's reducers
+        // throw on purpose — that is how its dialects reject illegal constructs
+        // (`bench/jess/digest.ts:64`). A boundary that leaked `ctx.trivia` and
+        // five capture sinks on the way out would corrupt every subsequent parse
+        // through the same context, so the handler IS the semantics here.
+        //
+        // `cstCaptureActive` IS THE SAVED STATE, read BEFORE the sinks are
+        // cleared — the leaf this body contributes goes to the OUTER collector.
+        // Inside a node the answer is the label's, and the call disappears.
+        const wasCap = L.buf ? 'true' : '(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)'
+        // `token()` additionally clears the TRIVIA scope and the root trivia
+        // log: its whole point is that the child sees no ambient skipping, so
+        // the match is one contiguous run of input (`ops.ts:180-190`).
+        return `${head}
+const sBuf=ctx._cstBuf,sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sOtl=ctx._triviaLog
+${isToken ? 'const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan,sRtl=ctx._rootTriviaLog\n' : ''}const wasCap=${wasCap}
+${isToken ? `_pfScan=null
+ctx.trivia=undefined
+ctx.triviaKindLabels=undefined
+` : ''}ctx._cstBuf=undefined
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined
+ctx._triviaLog=undefined
+${isToken ? 'ctx._rootTriviaLog=undefined\n' : ''}let v
+try{v=${child}(input,pos,ctx)}finally{
+${isToken ? `_pfScan=sScan
+ctx.trivia=sTri
+ctx.triviaKindLabels=sKinds
+ctx._rootTriviaLog=sRtl
+` : ''}ctx._cstBuf=sBuf
+ctx._cstChildren=sCh
+ctx._cstLeaves=sLv
+ctx._cstRawChildren=sRaw
+ctx._cstTriviaLog=sTl
+ctx._triviaLog=sOtl
+}
+if(v===FAIL)return FAIL
+const e=EC.e
+const out=${isToken ? 'input.slice(pos,e)' : `${fn}(v,{start:pos,end:e})`}
+if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:out,span:{start:pos,end:e}})
+EC.e=e
+return out
+}`
+      }
+
+      /* ── transaction ─────────────────────────────────────────────────────── */
+
+      case OP_ATTEMPT: {
+        const child = link(code[ip + 1]!)
+        const p = tmp()
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+if(v!==FAIL)return v
+${emitRollback(p, L.buf, sinks)}
+if(ctx._fc===true)return FAIL
+ctx._fe=pos
+return FAIL
+}`
+      }
+
+      case OP_NOT: {
+        const child = link(code[ip + 1]!)
+        const xf = fxRef(code[ip + 2]!)
+        const p = tmp()
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+${emitRollback(p, L.buf, sinks)}
+if(v===FAIL){EC.e=pos;return null}
+ctx._fe=pos
+ctx._fx=${xf}
+return FAIL
+}`
+      }
+
+      case OP_PEEK: {
+        const child = link(code[ip + 1]!)
+        const xf = fxRef(code[ip + 2]!)
+        const p = tmp()
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+${emitRollback(p, L.buf, sinks)}
+if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+EC.e=pos
+return null
+}`
+      }
+
+      case OP_OPT: {
+        const child = link(code[ip + 1]!)
+        const p = tmp()
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+ctx._fc=false
+const v=${child}(input,pos,ctx)
+if(v===FAIL){
+if(ctx._fc===true)return FAIL
+${emitRollback(p, L.buf, sinks)}
+EC.e=pos
+return null
+}
+return v
+}`
+      }
+
+      case OP_SEQ:
+      case OP_SEQV:
+      case OP_SEQX: {
+        const fused = op === OP_SEQX
+        const base = fused ? ip + 3 : ip + 2
+        const n = code[fused ? ip + 2 : ip + 1]!
+        const wantValues = op !== OP_SEQV
+        // ADJACENCY changes the PARENT's term-boundary emission: the assertion
+        // must be answered at the cursor, BEFORE the ambient trivia scan.
+        // Refused rather than lowered wrong — a piece handed the post-scan
+        // position finds the gap already consumed and answers "adjacent" every
+        // time, SILENTLY (`ops.ts:226-251`).
+        for (let i = 1; i < n; i++) {
+          if (code[code[base + i]!] === OP_ADJ) {
+            throw new Unemittable('a sequence carrying an adjacency assertion (OP_ADJ)')
+          }
+        }
+        const fn = fused ? fnRef(code[ip + 1]!) : undefined
+        const kids: string[] = []
+        for (let i = 0; i < n; i++) kids.push(link(code[base + i]!))
+        /**
+         * A RECOVERY SEQUENCE PUBLISHES `ctx._sync`, and that is the WHOLE of
+         * "recovery config" — no grammar carries any (`assemble.ts:1446`).
+         *
+         * Before term `i`, the sentinel for the union of every LATER term's first
+         * set becomes the sync point a list nested in that term resyncs to, so a
+         * `sepBy` inside `sequence('{', list, '}')` finds `}` with nothing
+         * annotated. Where there is no usable local follow — the last term, an
+         * `any` first set — the INHERITED sentinel stays published, which is how
+         * an enclosing delimiter reaches across a rule boundary. `sentRef` emits
+         * the literal `undefined` for that case, so it costs no array read.
+         *
+         * THE `n` SYNC OPERANDS SIT AFTER THE `n` CHILD OPERANDS, laid down by
+         * `encodeTable({ recovery })` — the same operands `assemble.ts:1468`
+         * reads, at the same offsets.
+         *
+         * RESTORED IN A `finally`, matching `sequence()`'s own
+         * (`combinators/sequence.ts:105`) and the closure engine's. `emitTerm`
+         * emits `return FAIL` INLINE at several points, so a restore placed on
+         * the fall-through paths alone would leak a stale sentinel out of exactly
+         * the failure the recovery path is about to read. `finally` is the only
+         * placement that covers an inlined return, and it is on the tolerant
+         * assembly only — the strict one emits none of this.
+         */
+        const sy = REC ? `${tmp()}sy` : ''
+        const pub = (i: number): string => {
+          const s = sentRef(code[base + n + i]!)
+          return s === 'undefined' ? `ctx._sync=${sy}` : `ctx._sync=${s}??${sy}`
+        }
+        const parts: string[] = [head]
+        if (REC) parts.push(`const ${sy}=ctx._sync`, 'try{', pub(0))
+        parts.push(`const v0=${kids[0]}(input,pos,ctx)`, 'if(v0===FAIL)return FAIL')
+        const close = (): string => REC ? `${parts.join('\n')}\n}finally{ctx._sync=${sy}}\n}` : `${parts.join('\n')}\n}`
+        if (n === 1) {
+          parts.push(fused ? `return ${fn}([v0],{start:pos,end:EC.e})` : wantValues ? 'return [v0]' : 'return undefined')
+          return close()
+        }
+        parts.push('let cur=EC.e')
+        const names: string[] = ['v0']
+        for (let i = 1; i < n; i++) {
+          const vn = `v${i}`
+          parts.push(`let ${vn}`)
+          if (REC) parts.push(pub(i))
+          parts.push(emitTerm(kids[i]!, vn, tmp(), L, skipFor(L), sinks))
+          names.push(vn)
+        }
+        parts.push('EC.e=cur')
+        parts.push(fused
+          ? `return ${fn}([${names.join(',')}],{start:pos,end:cur})`
+          : wantValues ? `return [${names.join(',')}]` : 'return undefined')
+        return close()
+      }
+
+      case OP_CHOICE: {
+        const table = disp[code[ip + 1]!]!
+        const n = code[ip + 2]!
+        const choiceFx = fxRef(code[ip + 3]!)
+        const base = ip + 4
+        const arms: string[] = []
+        for (let i = 0; i < n; i++) arms.push(link(code[base + i]!))
+        const axi = armExpected.push(
+          Array.from({ length: n }, (_, i) => t.fx[code[base + n + i]!] as readonly string[]),
+        ) - 1
+        armExpectedPlan.push(Array.from({ length: n }, (_, i) => code[base + n + i]!))
+        const afx = hoist('afx', `AFX[${axi}]`)
+
+        if (table.exclusive) {
+          // NO OPEN ARMS EXIST under `exclusive` — `resolveDispatch` clears the
+          // flag for any arm whose class is −1 — so there is no fallback loop.
+          const di = code[ip + 1]!
+          const asc = hoist('as', `DISP[${di}].ascii`)
+          const hiArr = table.hi
+          // Arms named, one `case` each: the interpreter's `arms[arm](…)` is an
+          // array index feeding ONE call site, which is the megamorphic site
+          // this unit exists to remove.
+          const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join('\n')
+          return `${head}
+const c=lead(input,pos)
+let arm=-1
+if(c>=0&&c<128){const a=${asc}[c];if(a!==0)arm=a-1}
+${hiArr.length === 0 ? '' : `else if(c>=128){const h=${hoist('hi', `DISP[${di}].hi`)}
+for(let i=0;i<h.length;i+=3){if(c>=h[i]&&c<=h[i+1]){arm=h[i+2];break}}}`}
+if(arm>=0){
+ctx._fc=false
+let v
+switch(arm){
+${armSwitch}
+}
+if(v!==FAIL)return v
+if(ctx._fc===true)return FAIL
+const af=ctx._fx
+if(af!==undefined&&af.length>0){ctx._fe=pos;return FAIL}
+}
+ctx._fe=pos;ctx._fx=${choiceFx}
+return FAIL
+}`
+        }
+
+        // THE PER-ARM GATE. `assemble.ts` precomputes a candidate bitmask so one
+        // `Uint32Array` load replaces `n` class tests, then walks the set bits
+        // through `arms[i]`. The mask survives here; the indexed CALL does not.
+        const ci = classes.push(Array.from({ length: n }, (_, i) => table.armCls[i] ?? null)) - 1
+        // `resolveDispatch` builds `armCls[a]` as `cc[disp[di][a]]`, or null when
+        // that index is negative (program.ts:419-423), so the arm's CLASS INDEX
+        // is the dispatch row itself. Nothing is re-derived here.
+        classPlan.push(Array.from({ length: n }, (_, i) => prog.disp[code[ip + 1]!]![i] ?? -1))
+        const gates = classes[ci]!
+        const gRef = hoist('g', `CLS[${ci}]`)
+        const maskable = n <= 32
+        let maskName = ''
+        if (maskable) {
+          maskName = hoist('mk', `MASK[${masks.push(maskForClassRow(gates)) - 1}]`)
+          // The mask is a pure function of `gates`, i.e. of `CLS[ci]`, so the
+          // plan records the class-pool index rather than 129 words per site.
+          maskPlan.push(ci)
+        }
+        const p = tmp()
+        // THE SKIPPED ARMS' SETS STAY LAZY. `prev` and the catch-up loop are the
+        // closure engine's, kept verbatim: they run only on a FAILURE path, and
+        // an arm that MATCHES returns without paying for any of it. Unrolling
+        // them would put an `_accSet` — and its `slice()` — on the success path.
+        const maskArms = arms.map((a, i) => `
+if((bits&${1 << i})!==0){
+ctx._fc=false
+{const v=${a}(input,pos,ctx)
+if(v!==FAIL)return v}
+for(let j=prev;j<${i};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+prev=${i + 1}
+acc=_accSet(ctx._fx,acc)
+if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
+${emitRollback(p, L.buf, sinks)}
+}`).join('')
+
+        const generalArms = arms.map((a, i) => `
+if(${gRef}[${i}]===null||classHas(${gRef}[${i}],c)){
+ctx._fc=false
+{const v=${a}(input,pos,ctx)
+if(v!==FAIL)return v}
+acc=_accSet(ctx._fx,acc)
+if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
+${emitRollback(p, L.buf, sinks)}
+}else acc=_accSet(${afx}[${i}],acc)`).join('')
+
+        return `${head}
+const c=lead(input,pos)
+${emitMark(p, L.buf, sinks)}
+let acc
+${maskable ? `if(c<128){
+const bits=${maskName}[c<0?128:c]
+let prev=0
+${maskArms}
+for(let j=prev;j<${n};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
+return FAIL
+}
+` : ''}${generalArms}
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
+return FAIL
+}`
+      }
+
+      case OP_DISPATCH: {
+        const di = code[ip + 2]!
+        const spec = dsp[di]!
+        const selector = link(code[ip + 1]!)
+        const otherIp = code[ip + 3]!
+        const other = otherIp >= 0 ? link(otherIp) : undefined
+        const otherRouted = code[ip + 4]! === 1
+        const n = code[ip + 5]!
+        const armBase = ip + 6
+        const arms: string[] = []
+        for (let i = 0; i < n; i++) arms.push(link(code[armBase + i]!))
+        const bk = hoist('bk', `DSP[${di}].byKey`)
+        const rt = hoist('rt', `DSP[${di}].routed`)
+        const dx = hoist('dx', `DSP[${di}].expected`)
+        // THE MATCHER ARMS, AS SOURCE. `exec.ts`'s `linkMatcher` mints one
+        // closure per arm from four literals it already has in hand; the four
+        // are TABLE DATA, so here they are the test itself and no closure, no
+        // pool and no indexed call exist. Kinds are `matcherClaims`'s exactly
+        // — 0/1 raw prefix/suffix, 3/4 the pre-folded pair, anything else a
+        // regex. The regex is built PER TEST, deliberately: a hoisted one
+        // carries `lastIndex` across parses whenever the author's pattern is
+        // sticky or global (`exec.ts:140-144`).
+        const claims = (m: readonly [number, string, string, number]): string => {
+          switch (m[0]) {
+            case 0: return `key.startsWith(${q(m[1])})`
+            case 1: return `key.endsWith(${q(m[1])})`
+            case 3: return `asciiFoldKey(key).startsWith(${q(m[1])})`
+            case 4: return `asciiFoldKey(key).endsWith(${q(m[1])})`
+            default: return `new RegExp(${q(m[1])},${q(m[2])}).test(key)`
+          }
+        }
+        const chain = spec.match.length === 0
+          ? ''
+          : `if(arm===undefined){\n${spec.match.map((m, i) => `${i === 0 ? '' : 'else '}if(${claims(m)})arm=${m[3]}`).join('\n')}\n}\n`
+        const fold = spec.byFold.size > 0
+          ? `if(arm===undefined)arm=${hoist('bf', `DSP[${di}].byFold`)}.get(asciiFoldKey(key))\n`
+          : ''
+        const m1 = tmp()
+        const m2 = tmp()
+        // THE SELECTOR RUNS ONCE and the key it returns picks the arm — that is
+        // what `dispatch()` buys over a choice of arms that each re-parse the
+        // opener. A routed arm rewinds the selector's trivia capture and gets
+        // the token handed to it (`OP_ROUTED`) instead of re-matching it.
+        return `${head}
+${emitMark(m1, L.buf, sinks)}
+const sv=${selector}(input,pos,ctx)
+if(sv===FAIL)return FAIL
+const selEnd=EC.e
+const key=sv
+let arm=${bk}.get(key)
+${fold}${chain}let ur
+if(arm===undefined){
+${other === undefined ? `ctx._fe=selEnd;ctx._fx=${dx};return FAIL` : `ur=${String(otherRouted)}`}
+}else ur=${rt}[arm]===1
+const savedRouted=ctx._routed
+${emitMark(m2, L.buf, sinks)}
+if(ur){
+${emitRollback(m1, L.buf, sinks)}
+${emitMark(m2, L.buf, sinks, false)}
+ctx._routed={value:key,span:{start:pos,end:selEnd}}
+}
+const at=ur?pos:selEnd
+let v
+switch(arm){
+${arms.map((a, i) => `case ${i}:v=${a}(input,at,ctx);break`).join('\n')}
+${other === undefined ? '' : `default:v=${other}(input,at,ctx)`}
+}
+if(ur)ctx._routed=savedRouted
+if(v===FAIL){
+${emitRollback(m2, L.buf, sinks)}
+ctx._fc=true
+return FAIL
+}
+return [key,v]
+}`
+      }
+
+      case OP_REP:
+      case OP_REPV: {
+        const child = link(code[ip + 1]!)
+        const min = code[ip + 2]!
+        const max = code[ip + 3]!
+        const sepIp = code[ip + 4]!
+        const sep = sepIp >= 0 ? link(sepIp) : undefined
+        const flags = code[ip + 5]!
+        const keepSeparators = (flags & 2) !== 0
+        const trailingAllowed = (flags & 1) !== 0
+        const reportItem = (flags & 4) !== 0
+        const itemFx = reportItem ? fxRef(code[ip + 6]!) : 'EMPTY_FX'
+        const collect = op === OP_REP
+        const skipBeforeFirst = sepIp < 0 && min === 0
+        const p = tmp()
+        // `viaRepItem` is `sep === undefined && count >= min && (count > 0 ||
+        // skipBeforeFirst)`. Two of its three conjuncts are table data, so only
+        // what survives them is emitted.
+        const via = sep !== undefined
+          ? 'false'
+          : min === 0
+            ? (skipBeforeFirst ? 'true' : 'count>0')
+            : `count>=${min}&&count>0`
+        const leadTrivia = skipBeforeFirst ? 'true' : 'count>0'
+        // THE TWO LOOP-INVARIANT HOISTS, RESOLVED AT EMIT WHERE THE LABEL ANSWERS
+        // THEM. `hasTrivia` is the site's trivia scope; `needMark` is implied by
+        // an open `_cstBuf`. Both were read once per repetition SITE, which is
+        // cheap on its own and is not the point — what they gated was a branch
+        // per item and a branch at every one of the five rollback points below.
+        const skip = skipFor(L)
+        const knownTrivia = L.tri === TRI_NONE ? false : L.tri !== TRI_UNKNOWN ? true : undefined
+        const hasTrivia = knownTrivia === undefined ? 'hasTrivia' : String(knownTrivia)
+        const needMark = L.buf ? 'true' : 'needMark'
+        // THE `_fields` AND `_errors` MARKS ARE TAKEN ONLY WHERE THE TABLE HAS A
+        // WRITER, which is the same emit-time census `emitMark` applies to the
+        // non-loop marks. Before `OP_FIELD` and `OP_EXPECT` were emittable the
+        // answer was "never"; it is now "per table", and a grammar with no field
+        // still pays neither the two loads nor the two stores per item.
+        const pfd = sinks.fd ? `${p}fd` : '0'
+        const per = sinks.er ? `${p}er` : 'undefined'
+        const rb = L.buf
+          ? `_rbBuf(ctx,${p}raw,${p}tl,${p}lv,${p}lg,${p}rt)${sinks.fd ? `\nif(ctx._fields!==undefined&&ctx._fields.length!==${p}fd)ctx._fields.length=${p}fd` : ''}${sinks.er ? `\nif(ctx._errors!==undefined&&ctx._errors.length!==${p}er)ctx._errors.length=${p}er` : ''}`
+          : `if(needMark)rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)`
+        const markSinks = `${sinks.fd ? `\n${p}fd=ctx._fields!==undefined?ctx._fields.length:0` : ''}${sinks.er ? `\n${p}er=ctx._errors!==undefined?ctx._errors.length:0` : ''}`
+        const markBody = L.buf
+          ? `const b=ctx._cstBuf
+const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${p}tl=l!==undefined?l.length:0
+${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}`
+          : `if(needMark){
+const b=ctx._cstBuf
+if(b!==undefined){
+const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${p}tl=l!==undefined?l.length:0
+}else{
+${p}raw=ctx._cstRawChildren!==undefined?ctx._cstRawChildren.length:0
+${p}tl=ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0
+${p}lv=ctx._cstLeaves!==undefined?ctx._cstLeaves.length:0
+}
+${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
+}`
+        /**
+         * TOLERANT RECOVERY — the SAME functions the other three engines call
+         * (`recovery/scan.ts`), so an error's span, its expected set and its CST
+         * embedding are produced once and cannot drift between engines.
+         *
+         * Reached only in a recovery table, and inside it only on the FAILURE of
+         * an element, so a matching item pays one `_sync` read at entry and
+         * nothing else. Everything else in this loop is the emitted strict loop
+         * unchanged — which is the whole point, and what the top-level refusal
+         * this replaces was giving up.
+         *
+         * THE FOUR AGREEMENTS WITH `assemble.ts:2036`, each load-bearing:
+         *  - a MANDATORY item of a separator-less repeat does NOT recover, so the
+         *    gate is `sep !== undefined || count >= min`. Both conjuncts are
+         *    table data here, so the test is CONSTANT-FOLDED rather than run.
+         *  - the check is `matchesAt(mySync, itemStart)`: sitting ON the sync
+         *    token is a clean list end, not junk, and `itemStart` is past any
+         *    leading trivia so trivia is never swallowed into the error span.
+         *  - a separated list scans to its OWN separator or the enclosing
+         *    delimiter (`orSentinel`); a separator-less one to the inherited
+         *    sentinel alone.
+         *  - the separator-less path rolls leading trivia back BEFORE recovering
+         *    and the separated path does NOT — a consumed separator and the error
+         *    after it both belong to the list (repeat.ts:533). This is why the
+         *    strict loop's unconditional `${'${rb}'}` could not simply be reused.
+         *
+         * `mySync` IS CAPTURED AT ENTRY, not read per item: an element's own
+         * sequence publishes over `_sync` while it runs. The interpreter restores
+         * in a `finally`, codegen saves at entry — same value, and so does this.
+         */
+        const my = `${p}my`
+        // `reportItem` gates the FAILURE report only. `recoverScan`'s expected set
+        // is taken unconditionally by the closure engine (`assemble.ts:2067`), so
+        // it is resolved separately from `itemFx` — reusing that one would hand
+        // `EMPTY_FX` to every recovered error in a grammar that does not report.
+        const recFx = REC ? fxRef(code[ip + 6]!) : ''
+        const sepSent = REC ? sentRef(code[ip + 7]!) : 'undefined'
+        const recSent = sep === undefined
+          ? my
+          : sepSent === 'undefined'
+            ? `orSentinel(${my},undefined)`
+            : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`
+        const recGate = sep !== undefined || min === 0 ? '' : `count>=${min}&&`
+        const recBranch = !REC ? '' : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
+${sep === undefined ? `${rb}\n` : ''}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
+${collect ? 'out.push(rr.error)\n' : ''}captureError(ctx,rr.error)
+count++
+cur=rr.end
+continue
+}
+`
+        return `${head}
+const out=${collect ? '[]' : 'undefined'}
+${knownTrivia === undefined ? 'const hasTrivia=ctx.trivia!==undefined\n' : ''}${L.buf ? '' : 'const needMark=_rollbackNeeded(ctx)\n'}${REC ? `const ${my}=ctx._sync\n` : ''}let cur=pos
+let count=0
+for(;;){
+${max >= 0 ? `if(count>=${max})break\n` : ''}${sep !== undefined ? `if(count>0&&count>=${min}&&cur>=input.length)break\n` : ''}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ''}${sinks.er ? `,${p}er=0` : ''}
+${markBody}
+let itemStart=cur
+let sepEnd=-1
+${sep !== undefined ? `if(count>0){
+const lb=cstLeavesLen(ctx)
+let sp=cur
+${hasTrivia === 'false' ? '' : hasTrivia === 'true' ? `sp=${skip}(input,sp,ctx)\n` : `if(hasTrivia)sp=${skip}(input,sp,ctx)\n`}ctx._fc=false
+const sv=${sep}(input,sp,ctx)
+if(sv===FAIL){
+${rb}
+if(ctx._fc===true)return FAIL
+break
+}
+${keepSeparators ? '' : 'demoteCapturedToRaw(ctx,lb)\n'}sepEnd=EC.e
+itemStart=${hasTrivia === 'false' ? 'EC.e' : hasTrivia === 'true' ? `${skip}(input,EC.e,ctx)` : `hasTrivia?${skip}(input,EC.e,ctx):EC.e`}
+}else ${leadSkip(hasTrivia, leadTrivia, skip)}
+` : `${leadSkip(hasTrivia, leadTrivia, skip)}
+`}if(itemStart>=input.length&&${via}){
+${rb}
+${trailingAllowed ? 'if(sepEnd>=0)cur=sepEnd\n' : ''}break
+}
+ctx._fc=false
+const v=${child}(input,itemStart,ctx)
+if(v===FAIL){
+${REC
+  // THE ROLLBACK MOVES INSIDE THE ARMS. The strict loop rolls back
+  // unconditionally before testing `_fc`, which is sound because every path out
+  // of it rolls back. The recovery arm is the one path that must NOT: a
+  // separated list keeps the consumed separator and the trivia after it, both of
+  // which belong to the list (repeat.ts:533). So `committed` is tested first and
+  // each arm takes its own rollback — the same order as `assemble.ts:2113`.
+  ? `if(ctx._fc===true){
+${rb}
+return FAIL
+}
+${recBranch}${rb}`
+  : `${rb}
+if(ctx._fc===true)return FAIL`}
+${trailingAllowed ? 'if(sepEnd>=0)cur=sepEnd\n' : ''}break
+}
+if(EC.e===itemStart&&${via}){
+${rb}
+break
+}
+${collect ? 'out.push(v)\n' : ''}cur=EC.e
+count++
+}
+${min > 0 ? `if(count<${min}){
+${reportItem ? `ctx._fe=cur;ctx._fx=${itemFx}\n` : ''}return FAIL
+}
+` : ''}EC.e=cur
+return out
+}`
+      }
+
+      case OP_NODE:
+      case OP_NODE_TRACK: {
+        const flags = code[ip + 3]!
+        const child = link(code[ip + 2]!)
+        const proj = code[ip + 4]!
+        const buildIdx = code[ip + 1]!
+        const type = k[code[ip + 5]!] as string
+        const tagIdx = code[ip + 6]!
+        const tags = tagIdx < 0 ? 'undefined' : kRef(tagIdx)
+        const tracked = op === OP_NODE_TRACK
+        const readsTrivia = (flags & 4) !== 0
+        const readsState = (flags & 8) !== 0
+        const hasFields = (flags & 16) !== 0
+        const collapse = (flags & 32) !== 0
+        const unwrap = (flags & 64) !== 0
+        const trailingTrivia = (flags & 128) !== 0
+        // HOST MODE IS AN OPTION, and it decided five runtime ternaries in the
+        // interpreter's node case — the most-executed non-terminal in any of
+        // these grammars. It selects the emitted shape instead.
+        const build = buildIdx >= 0 ? fnRef(buildIdx) : undefined
+        const structural = build === undefined && proj < 0
+        const grammarCapture = (flags & 1) !== 0 || trailingTrivia
+        const hostCapturesThisType = structural && cfg.hostCaptureTrivia !== undefined
+          ? cfg.hostCaptureTrivia(type)
+          : undefined
+        const wantFields = hasFields || hostCst
+        const captureWide = readsTrivia || hostCst
+          ? !structural || grammarCapture || hostCapturesThisType !== false
+          : hostCapturesThisType === true
+        const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap
+        const ty = q(type)
+        const stArg = readsState ? 'st' : '(ctx.state!==undefined?Object.assign({},ctx.state):undefined)'
+        const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`
+        let value: string
+        if (proj >= 0) {
+          value = hostCst
+            ? `nd=_pfHost!==undefined?${hostCall}:projectChild(kids,${proj},${ty})`
+            : `nd=projectChild(kids,${proj},${ty})`
+        } else if (build !== undefined) {
+          // A direct builder is bypassed under a CST host.
+          const direct = `${build}(kids,fieldMap,span,rawKids,${captureWide ? 'tlog' : 'EMPTY_TL'},st)`
+          value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:${direct}` : `nd=${direct}`
+        } else {
+          value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):{_tag:'node',type:${ty},span,state:st??null,children:kids}`
+        }
+        // HOST COLLAPSE applies wherever the node's VALUE comes from the host —
+        // any node under a CST host, not only the builder-less ones.
+        const collapsible = keepChildren && (hostCst || (build === undefined && proj < 0))
+        const openCapture = keepChildren
+          ? `const buf={}
+ctx._cstBuf=buf
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined`
+          : `const buf={rawOnly:true}
+ctx._cstBuf=buf
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined`
+        const finishCapture = keepChildren
+          ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
+const hostKids=kids
+const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
+const tlog=buf.tl??EMPTY_TLOG`
+          : `const kids=EMPTY_CH
+const hostKids=kids
+const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
+const tlog=buf.tl??EMPTY_TLOG`
+        return `${head}
+const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
+${openCapture}
+ctx.captureTrivia=${captureWide}
+const savedFields=ctx._fields
+ctx._fields=${wantFields ? '[]' : 'undefined'}
+${structural ? `const savedMask=ctx._triviaCaptureMask
+if(_pfHost!==undefined&&_pfHost._parsemanTriviaKinds!==undefined)ctx._triviaCaptureMask=_pfHost._parsemanTriviaKinds(${ty})
+` : ''}const v=${child}(input,pos,ctx)
+${trailingTrivia && L.tri !== TRI_NONE
+  ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? '&&ctx.trivia!==undefined' : ''})EC.e=consumeTrivia(input,EC.e,ctx)\n`
+  : ''}const fieldMap=${wantFields ? 'buildFieldMap(ctx._fields)' : 'undefined'}
+ctx._fields=savedFields
+${structural ? 'ctx._triviaCaptureMask=savedMask\n' : ''}${finishCapture}
+ctx._cstBuf=sBuf
+ctx._cstChildren=sCh
+ctx._cstLeaves=sLv
+ctx._cstRawChildren=sRaw
+ctx._cstTriviaLog=sTl
+ctx.captureTrivia=sCap
+if(v===FAIL)return FAIL
+const end=EC.e
+const span=${tracked ? 'spanLines(ctx,pos,end)' : '{start:pos,end}'}
+const st=${readsState ? '(ctx.state!==undefined?Object.assign({},ctx.state):undefined)' : 'undefined'}
+let nd
+${unwrap ? 'if(kids.length===1)nd=unwrapChild(kids[0])\nelse ' : ''}${collapse ? 'if(kids.length===1)nd=kids[0]\nelse ' : ''}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
+else ` : ''}{${value}}
+${L.buf
+  // The OUTER buffer, which this body saved into `sBuf` before opening its own —
+  // so an in-node site's parent collector is present by the same fact.
+  ? 'pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))'
+  : 'if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))'}
+EC.e=end
+return nd
+}`
+      }
+
+      default:
+        throw new Unemittable(`OP_${OP_NAMES[op!] ?? String(op)}`)
+    }
+  }
+
+  const ruleEntries: string[] = []
+  for (const [rname, entryIp] of Object.entries(prog.rules)) {
+    // `_r_<Name>` — the composition surface, in `codegen.ts`'s own spelling and
+    // deliberately NOT namespaced, so a sibling calls it by name.
+    const target = link(entryIp)
+    const rn = `_r_${rname.replace(/[^A-Za-z0-9_$]/g, '_')}`
+    bodies.push(`const ${rn}=${target}`)
+    ruleEntries.push(`${q(rname)}:${rn}`)
+  }
+  // Sites the SCAN pool and the scan-skip sets reference. They are linked
+  // through `subtreeComb` outside the emitted scope, so they need names.
+  const extra: string[] = []
+  for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`)
+
+  // The per-label trivia scans sit AFTER the hoisted pool they close over: they
+  // are `function` declarations, so a body may call one that is textually below
+  // it, but the `const _ts<N>` each one reads must be initialised before any
+  // parse runs, not merely before the declaration is evaluated.
+  const source = `${RUNTIME_PRELUDE}
+${prelude.join('\n')}
+${skipDefs.join('\n')}
+${bodies.join('\n')}
+function _begin(ctx){
+const host=ctx.build
+if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
+_pfDepth++
+_pfScan=null
+_pfHost=host
+}
+function _finish(){
+if(_pfDepth<=0)throw new Error('parseman emitted table assembly frame underflow')
+_pfDepth--
+if(_pfDepth===0)return
+const prior=_pfFrames.pop()
+_pfScan=prior[0]
+_pfHost=prior[1]
+EC.e=prior[2]
+}
+return{
+pieces:{${ruleEntries.join(',')}},
+byIp:{${extra.join(',')}},
+end:function(){return EC.e},
+begin:_begin,
+finish:_finish
+}`
+
+  return {
+    source, reached, masks, classes, armExpected,
+    plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan },
+  }
+}