parseman 0.47.1 → 0.48.0

package/src/table/exec.ts

@@ -6,7 +6,10 @@ import { projectChild, unwrapChild } from '../combinators/node.ts'
 import { asciiFoldEq } from '../combinators/literal.ts'
 import { cstOutputHost } from '../compiler/build-arity.ts'
 import { consumeTrivia } from '../combinators/trivia-skip.ts'
-import { advanceTrivia, needsDeferredTriviaCommit, rollbackScannedTriviaAt, rollbackTrivia, rollbackTriviaAt, saveTriviaMark, scanTrivia, skipTriviaScanned, type FastTriviaScanner } from '../combinators/trivia-skip.ts'
+import {
+  advanceTrivia, commitTriviaScan, needsDeferredTriviaCommit, rollbackScannedTriviaAt, rollbackTrivia,
+  rollbackTriviaAt, saveTriviaMark, scanTriviaCompact, skipTriviaScanned, type FastTriviaScanner,
+} from '../combinators/trivia-skip.ts'
 import {
   beginCstNodeCapture, cstCaptureActive, cstLeavesLen, cstRawLen, cstTlLen,
   demoteCapturedToRaw, endCstNodeCapture, pushCstChild, pushCstLeaf,
@@ -19,6 +22,7 @@ import {
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD, OP_ATTEMPT, OP_LABEL,
   OP_COV,
   OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE,
+  OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
 import { adjacencyHolds, adjacencyMisuse } from '../combinators/adjacency.ts'
 import { failAt } from '../combinators/probe.ts'
@@ -41,9 +45,10 @@ import { refuseUnclassifiedRootScope } from '../cst/root-trivia-scope.ts'
 import { captureError, firstSetSentinel, matchesAt, orSentinel, recoverScan } from '../recovery/scan.ts'
 import {
   decodeClassSpec, expandCompact, resolveTable,
-  type CompactProgram, type ResolvedClass, type ResolvedDispatch, type ResolvedDispatchSpec,
+  type CompactProgram, type ResolvedClass, type ResolvedDispatch, type ResolvedDispatchSpec, type ResolvedTable,
   type SubtreeRef, type TableProgram, type TableRule,
 } from './program.ts'
+import { scalarTerminalNotChild } from './scalar-terminal.ts'
 
 /**
  * THE SHARED DRIVER.
@@ -199,6 +204,8 @@ function makeDriver(
   fx: readonly (readonly string[])[],
   disp: readonly ResolvedDispatch[],
   dsp: readonly ResolvedDispatchSpec[],
+  lex: readonly ((input: string, pos: number) => number)[],
+  lexPrograms: ResolvedTable['lexPrograms'],
   trivia: readonly unknown[],
   triviaScan: readonly (FastTriviaScanner | null)[],
   triviaLabelled: readonly boolean[],
@@ -353,9 +360,7 @@ function makeDriver(
     // grammar that already had a scanner — keeps the exact branch it had.
     if (s !== null) return skipTriviaScanned(s, input, cur, ctx)
     if (needsDeferredTriviaCommit(ctx)) {
-      const scan = scanTrivia(input, cur, ctx)
-      scan.commit()
-      return scan.end
+      return commitTriviaScan(scanTriviaCompact(input, cur, ctx))
     }
     return advanceTrivia(input, cur, ctx)
   }
@@ -622,6 +627,8 @@ function makeDriver(
             ctx._routed = savedRouted
           }
         } else {
+          // The reference engine mirrors dispatch.parse(): plain arms do not
+          // install routed state and stay outside the exception guard.
           v = exec(target, input, selEnd, ctx)
         }
         if (v === FAIL) {
@@ -692,6 +699,84 @@ function makeDriver(
         return value
       }
 
+      case OP_LEX_BODY: {
+        const recognized = lex[code[ip + 1]!]!(input, pos)
+        if (recognized < 0) {
+          ctx._fe = pos
+          ctx._fx = fx[code[ip + 2]!] as string[]
+          if (ctx._probe !== undefined) failAt(ctx, ctx._fx, pos)
+          return FAIL
+        }
+        const lineFlags = code[ip + 4]!
+        const hasSuffix = (lineFlags & 4) !== 0
+        const suffixMatched = hasSuffix && recognized % 2 === 1
+        const end = (recognized - (suffixMatched ? 1 : 0)) / 2
+        if ((lineFlags & 1) !== 0) trackLines(ctx, input, suffixMatched ? end - 1 : end)
+        if (hasSuffix) ctx._fc = false
+        if (hasSuffix && suffixMatched && (lineFlags & 2) !== 0) trackLines(ctx, input, end)
+        if (hasSuffix && !suffixMatched) {
+          const suffixExpected = fx[code[ip + 3]!] as string[]
+          ctx._fe = end
+          ctx._fx = suffixExpected
+          if (ctx._probe !== undefined) failAt(ctx, suffixExpected, end)
+        }
+        const value = input.slice(pos, end)
+        if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span: { start: pos, end } })
+        EC.e = end
+        return value
+      }
+
+      case OP_LEX_PROGRAM: {
+        const run = lexPrograms[code[ip + 1]!]!
+        const scanId = run.scan
+        if (scanId === undefined) {
+          const end = run(input, pos, ctx)
+          if (end < 0) return FAIL
+          const value = input.slice(pos, end)
+          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: 'leaf', value, span: { start: pos, end } })
+          EC.e = end
+          return value
+        }
+        // The recognizer is the canonical balanced() pool entry. Reproduce the
+        // enclosing token boundary here so its internal token leaf and skippers
+        // cannot publish into the outer collector; this row publishes one leaf.
+        const sTrivia = ctx.trivia, sKinds = ctx.triviaKindLabels
+        const sBuf = ctx._cstBuf, sChildren = ctx._cstChildren, sLeaves = ctx._cstLeaves
+        const sRaw = ctx._cstRawChildren, sTl = ctx._cstTriviaLog
+        const sOuterTl = ctx._triviaLog, sRootTl = ctx._rootTriviaLog
+        const wasCapturing = cstCaptureActive(ctx)
+        const sScan = SCAN
+        SCAN = 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
+        ctx._rootTriviaLog = undefined
+        let end: number
+        try { end = run(input, pos, ctx, scans[scanId]) }
+        finally {
+          SCAN = sScan
+          ctx.trivia = sTrivia
+          ctx.triviaKindLabels = sKinds
+          ctx._cstBuf = sBuf
+          ctx._cstChildren = sChildren
+          ctx._cstLeaves = sLeaves
+          ctx._cstRawChildren = sRaw
+          ctx._cstTriviaLog = sTl
+          ctx._triviaLog = sOuterTl
+          ctx._rootTriviaLog = sRootTl
+        }
+        if (end < 0) return FAIL
+        const value = input.slice(pos, end)
+        if (wasCapturing) pushCstLeaf(ctx, { _tag: 'leaf', value, span: { start: pos, end } })
+        EC.e = end
+        return value
+      }
+
       case OP_SCAN: {
         const c = scans[code[ip + 1]!]!
         const r = c.parse(input, pos, ctx)
@@ -854,7 +939,9 @@ function makeDriver(
         if (REC) ctx._sync = inheritedSync
         EC.e = cur
         if (fused) {
-          const fn = fns[code[ip + 1]!] as (value: unknown, span: { start: number; end: number }) => unknown
+          const reducer = code[ip + 1]!
+          if (reducer < 0) return values![~reducer]
+          const fn = fns[reducer] as (value: unknown, span: { start: number; end: number }) => unknown
           if (COUNT) siteFn('SEQX fn()', fn)
           return fn(values, { start: pos, end: cur })
         }
@@ -1116,6 +1203,11 @@ function makeDriver(
         const mySync = REC ? ctx._sync : undefined
         const recFx = REC ? fx[code[ip + 6]!] as string[] : undefined
         const sepSent = REC ? sentinelFor(code[ip + 7]!) : undefined
+        const itemClassIndex = sep < 0 ? code[ip + 7]! : -1
+        const itemClass = REC && itemClassIndex >= 0 ? cc[itemClassIndex]! : undefined
+        // `completionsAt` observes failures swallowed by an optional iteration;
+        // tolerant recovery does too. Both keep the ordinary child path.
+        const gateItems = itemClass !== undefined && ctx._tolerant !== true && ctx._probe === undefined
         let cur = pos
         let count = 0
         for (;;) {
@@ -1128,6 +1220,8 @@ function makeDriver(
           // must attempt the separator so its failure sets the expected set, which
           // is the only thing an under-`min` list has to report.
           if (sep >= 0 && count > 0 && count >= min && cur >= input.length) break
+          if (count >= min && sep < 0 && !hasTrivia
+            && gateItems && !classHas(itemClass!, lead(input, cur))) break
           // One mark pair for the whole loop when a rollback is even possible,
           // refreshed per iteration rather than reallocated.
           // SCALAR MARKS. This loop took TWO allocations per item (a CST mark and
@@ -1199,6 +1293,11 @@ function makeDriver(
             if (trailingAllowed && sepEnd >= 0) cur = sepEnd
             break
           }
+          if (count >= min && gateItems && !classHas(itemClass!, lead(input, itemStart))) {
+            if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
+            if (trailingAllowed && sepEnd >= 0) cur = sepEnd
+            break
+          }
           ctx._fc = false
           const v = exec(child, input, itemStart, ctx)
           if (v === FAIL) {
@@ -1454,6 +1553,15 @@ function makeDriver(
       }
 
       case OP_NOT: {
+        // The shipping generic closure/emitted NOT bodies predate pure-global
+        // lookahead rollback. Keep the reference driver aligned with them for
+        // every generic child; only the direct-terminal shape this lane replaces
+        // needs the reference oracle to hide the terminal's diagnostic writes.
+        const scalarChild = scalarTerminalNotChild(code, ip) >= 0
+        const savedFc = scalarChild ? ctx._fc : false
+        const savedFe = scalarChild ? ctx._fe : -1
+        const savedFx = scalarChild ? ctx._fx : undefined
+        const savedProbe = scalarChild ? ctx._probe?.best : undefined
         const need = rollbackNeeded(ctx)
         const mRaw = need ? cstRawLen(ctx) : 0
         const mTl = need ? cstTlLen(ctx) : 0
@@ -1464,6 +1572,12 @@ function makeDriver(
         const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0
         const v = exec(code[ip + 1]!, input, pos, ctx)
         if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot)
+        if (scalarChild) {
+          ctx._fc = savedFc
+          ctx._fe = savedFe
+          ctx._fx = savedFx
+          if (ctx._probe !== undefined) ctx._probe.best = savedProbe ?? null
+        }
         if (v === FAIL) { EC.e = pos; return null }
         // `not.ts:50` — the ASSERTION's own set, at the assertion's position.
         ctx._fe = pos
@@ -1651,7 +1765,7 @@ export function execRules(
   const prog = expandCompact(source)
   const t = resolveTable(prog)
   const scan = opts.leafSwap === false ? t.triviaScan.map(() => null) : t.triviaScan
-  const d = makeDriver(t.code, t.k, t.fns, t.cc, t.fx, t.disp, t.dsp, t.trivia, scan, t.triviaLabelled, prog, newEndCell())
+  const d = makeDriver(t.code, t.k, t.fns, t.cc, t.fx, t.disp, t.dsp, t.lex, t.lexPrograms, t.trivia, scan, t.triviaLabelled, prog, newEndCell())
   const names = Object.keys(prog.rules)
   const entries = names.map(n => prog.rules[n]!)
   let last: unknown

package/src/table/lex-body.ts

@@ -0,0 +1,30 @@
+import type { LexBodySpec } from './program.ts'
+
+/** -1 fails. A success is `end * 2 + suffixMatched`, so the reader can
+ * reproduce optional()'s swallowed suffix failure without allocating a tuple. */
+export type LexBodyRecognizer = (input: string, pos: number) => number
+
+/** Build one selected lexical body from its numeric table row. Recognition is
+ * pure; diagnostics, token boundary state, source value and CST publication
+ * remain owned by the reader's OP_LEX_BODY shell. */
+export function buildLexBodyRecognizer(
+  spec: LexBodySpec,
+  constants: readonly unknown[],
+): LexBodyRecognizer {
+  const raw = constants[spec[0]]
+  if (!(raw instanceof RegExp)) {
+    throw new TypeError('table lexical body does not reference a RegExp constant')
+  }
+  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 0xFFFF) {
+    throw new TypeError('table lexical body suffix is not absent or one UTF-16 code unit')
+  }
+  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, '')}y`)
+  const suffix = spec[1]
+  return (input, pos) => {
+    re.lastIndex = pos
+    if (!re.test(input)) return -1
+    const end = re.lastIndex
+    if (suffix < 0) return end * 2
+    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2
+  }
+}

package/src/table/lex-program.ts

@@ -0,0 +1,422 @@
+import type { Combinator, ParseContext } from '../types.ts'
+import { failAt } from '../combinators/probe.ts'
+import type { LexBodyRecognizer } from './lex-body.ts'
+import type { LexProgramSpec, ResolvedClass } from './program.ts'
+
+/** A selected composite lexical body. Failure state is already published.
+ * `scan` is present only for the balanced shell and indexes the canonical
+ * driver-owned scan pool; it is not another recognizer implementation. */
+export type LexProgramRunner = {
+  (input: string, pos: number, ctx: ParseContext, scan?: Combinator<unknown>): number
+  readonly scan?: number
+}
+
+export const LEX_NODE_TERMINAL = 0
+export const LEX_NODE_SEQUENCE2 = 1
+export const LEX_NODE_SEQUENCE3 = 2
+export const LEX_NODE_SEQUENCE4 = 3
+export const LEX_NODE_SEQUENCE5 = 4
+export const LEX_NODE_CHOICE2 = 5
+export const LEX_NODE_CHOICE4 = 6
+export const LEX_NODE_CHOICE8 = 7
+export const LEX_NODE_NOT = 8
+export const LEX_NODE_OPTIONAL = 9
+
+export function lexProgramDigest(words: readonly number[]): number {
+  let hash = 0x811C9DC5
+  for (const word of words) {
+    hash ^= word | 0
+    hash = Math.imul(hash, 0x01000193)
+  }
+  return hash | 0
+}
+
+function classHas(cls: ResolvedClass, code: number): boolean {
+  if (code < 0) return false
+  if (code < 128) return cls.ascii[code] === 1
+  for (let i = 0; i < cls.hi.length; i += 2) {
+    if (code >= cls.hi[i]! && code <= cls.hi[i + 1]!) return true
+  }
+  return false
+}
+
+type PureLexRunner = (input: string, pos: number) => number
+type BuiltLexNode = { readonly match: PureLexRunner; readonly run: LexProgramRunner }
+const committed = (ctx: ParseContext): boolean => ctx._fc === true
+
+function trackLexLines(ctx: ParseContext, input: string, end: number): void {
+  let at = ctx._lineScannedTo ?? 0
+  const starts = ctx._lineStarts
+  if (starts === undefined || end <= at) return
+  while (at < end) {
+    if (input.charCodeAt(at) === 10) starts.push(at + 1)
+    at++
+  }
+  ctx._lineScannedTo = end
+}
+
+function terminalNode(
+  matcher: LexBodyRecognizer,
+  failure: readonly string[],
+  tracksLines: boolean,
+): BuiltLexNode {
+  const match: PureLexRunner = (input, pos) => {
+    const result = matcher(input, pos)
+    return result < 0 ? -1 : result / 2
+  }
+  return {
+    match,
+    run: (input, pos, ctx) => {
+      const end = match(input, pos)
+      if (end < 0) {
+        ctx._fe = pos
+        ctx._fx = failure as string[]
+        if (ctx._probe !== undefined) failAt(ctx, ctx._fx, pos)
+        return -1
+      }
+      if (tracksLines) trackLexLines(ctx, input, end)
+      return end
+    },
+  }
+}
+
+function sequence2(a: BuiltLexNode, b: BuiltLexNode): BuiltLexNode {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos)
+      return e0 < 0 ? -1 : b.match(input, e0)
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx)
+      if (e0 < 0) return -1
+      ctx._fc = false
+      return b.run(input, e0, ctx)
+    },
+  }
+}
+
+function sequence3(a: BuiltLexNode, b: BuiltLexNode, c: BuiltLexNode): BuiltLexNode {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos)
+      if (e0 < 0) return -1
+      const e1 = b.match(input, e0)
+      return e1 < 0 ? -1 : c.match(input, e1)
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx)
+      if (e0 < 0) return -1
+      ctx._fc = false
+      const e1 = b.run(input, e0, ctx)
+      if (e1 < 0) return -1
+      ctx._fc = false
+      return c.run(input, e1, ctx)
+    },
+  }
+}
+
+function sequence4(a: BuiltLexNode, b: BuiltLexNode, c: BuiltLexNode, d: BuiltLexNode): BuiltLexNode {
+  const abc = sequence3(a, b, c)
+  return {
+    match: (input, pos) => {
+      const end = abc.match(input, pos)
+      return end < 0 ? -1 : d.match(input, end)
+    },
+    run: (input, pos, ctx) => {
+      const end = abc.run(input, pos, ctx)
+      if (end < 0) return -1
+      ctx._fc = false
+      return d.run(input, end, ctx)
+    },
+  }
+}
+
+function sequence5(
+  a: BuiltLexNode, b: BuiltLexNode, c: BuiltLexNode, d: BuiltLexNode, e: BuiltLexNode,
+): BuiltLexNode {
+  const abcd = sequence4(a, b, c, d)
+  return {
+    match: (input, pos) => {
+      const end = abcd.match(input, pos)
+      return end < 0 ? -1 : e.match(input, end)
+    },
+    run: (input, pos, ctx) => {
+      const end = abcd.run(input, pos, ctx)
+      if (end < 0) return -1
+      ctx._fc = false
+      return e.run(input, end, ctx)
+    },
+  }
+}
+
+type ChoiceTail = (
+  input: string, pos: number, ctx: ParseContext, lead: number, acc: string[] | undefined,
+) => number
+
+function appendExpected(acc: string[] | undefined, values: readonly string[] | undefined): string[] | undefined {
+  if (values === undefined || values.length === 0) return acc
+  if (acc === undefined) return values.slice()
+  acc.push(...values)
+  return acc
+}
+
+function choiceNode(
+  arms: readonly BuiltLexNode[],
+  classes: readonly (ResolvedClass | undefined)[],
+  armExpected: readonly (readonly string[])[],
+  choiceExpected: readonly string[],
+): BuiltLexNode {
+  let matchTail: PureLexRunner = () => -1
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i]!, next = matchTail
+    matchTail = (input, pos) => {
+      const end = arm.match(input, pos)
+      return end < 0 ? next(input, pos) : end
+    }
+  }
+  let tail: ChoiceTail = (_input, pos, ctx, _lead, acc) => {
+    ctx._fe = pos
+    ctx._fx = acc ?? choiceExpected as string[]
+    return -1
+  }
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i]!, cls = classes[i], staticExpected = armExpected[i]!, next = tail
+    tail = (input, pos, ctx, lead, acc) => {
+      if (cls !== undefined && !classHas(cls, lead)) {
+        return next(input, pos, ctx, lead, appendExpected(acc, staticExpected))
+      }
+      ctx._fc = false
+      const end = arm.run(input, pos, ctx)
+      if (end >= 0) return end
+      const nextAcc = appendExpected(acc, ctx._fx)
+      if (committed(ctx)) {
+        if (nextAcc !== undefined) ctx._fx = nextAcc
+        return -1
+      }
+      return next(input, pos, ctx, lead, nextAcc)
+    }
+  }
+  return {
+    match: matchTail,
+    run: (input, pos, ctx) => tail(input, pos, ctx, pos < input.length ? input.codePointAt(pos)! : -1, undefined),
+  }
+}
+
+function notNode(body: BuiltLexNode, failure: readonly string[]): BuiltLexNode {
+  return {
+    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    run: (input, pos, ctx) => {
+      if (body.match(input, pos) < 0) return pos
+      ctx._fe = pos
+      ctx._fx = failure as string[]
+      return -1
+    },
+  }
+}
+
+function optionalNode(body: BuiltLexNode): BuiltLexNode {
+  return {
+    match: (input, pos) => {
+      const end = body.match(input, pos)
+      return end < 0 ? pos : end
+    },
+    run: (input, pos, ctx) => {
+      ctx._fc = false
+      const end = body.run(input, pos, ctx)
+      return end < 0 && !committed(ctx) ? pos : end
+    },
+  }
+}
+
+function fixedTreeRunner(
+  words: readonly number[],
+  matchers: readonly LexBodyRecognizer[],
+  classes: readonly ResolvedClass[],
+  expected: readonly (readonly string[])[],
+): LexProgramRunner {
+  const stack: BuiltLexNode[] = []
+  const pop = (): BuiltLexNode => {
+    const value = stack.pop()
+    if (value === undefined) throw new TypeError('table lexical tree has an incomplete fixed body')
+    return value
+  }
+  for (let at = 0; at < words.length;) {
+    const op = words[at++]!
+    if (op === LEX_NODE_TERMINAL) {
+      const matcher = matchers[words[at++]!], failure = expected[words[at++]!]
+      const tracks = words[at++]
+      if (matcher === undefined || failure === undefined || (tracks !== 0 && tracks !== 1)) {
+        throw new TypeError('table lexical tree terminal references an invalid pool entry')
+      }
+      stack.push(terminalNode(matcher, failure, tracks === 1))
+      continue
+    }
+    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
+      const count = op - LEX_NODE_SEQUENCE2 + 2
+      const nodes = Array.from({ length: count }, pop).reverse()
+      if (count === 2) stack.push(sequence2(nodes[0]!, nodes[1]!))
+      else if (count === 3) stack.push(sequence3(nodes[0]!, nodes[1]!, nodes[2]!))
+      else if (count === 4) stack.push(sequence4(nodes[0]!, nodes[1]!, nodes[2]!, nodes[3]!))
+      else stack.push(sequence5(nodes[0]!, nodes[1]!, nodes[2]!, nodes[3]!, nodes[4]!))
+      continue
+    }
+    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
+      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8
+      const choiceFx = expected[words[at++]!]
+      if (choiceFx === undefined) throw new TypeError('table lexical tree choice has an invalid expected set')
+      const armClasses: Array<ResolvedClass | undefined> = []
+      const armFx: Array<readonly string[]> = []
+      for (let i = 0; i < count; i++) {
+        const cls = words[at++]!, fx = expected[words[at++]!]
+        if (cls < -1 || (cls >= 0 && classes[cls] === undefined) || fx === undefined) {
+          throw new TypeError('table lexical tree choice references an invalid pool entry')
+        }
+        armClasses.push(cls < 0 ? undefined : classes[cls])
+        armFx.push(fx)
+      }
+      const arms = Array.from({ length: count }, pop).reverse()
+      stack.push(choiceNode(arms, armClasses, armFx, choiceFx))
+      continue
+    }
+    if (op === LEX_NODE_NOT) {
+      const failure = expected[words[at++]!]
+      if (failure === undefined) throw new TypeError('table lexical tree assertion has an invalid expected set')
+      stack.push(notNode(pop(), failure))
+      continue
+    }
+    if (op === LEX_NODE_OPTIONAL) { stack.push(optionalNode(pop())); continue }
+    throw new TypeError('table lexical tree has an unknown fixed body')
+  }
+  if (stack.length !== 1) throw new TypeError('table lexical tree does not resolve to one root body')
+  return stack[0]!.run
+}
+
+/** Decode one fixed selected-body tuple. There is no lexical opcode loop on
+ * the parse path: each supported tuple becomes one scalar closure here. */
+export function buildLexProgramRunner(
+  spec: LexProgramSpec,
+  matchers: readonly LexBodyRecognizer[],
+  classes: readonly ResolvedClass[],
+  expected: readonly (readonly string[])[],
+): LexProgramRunner {
+  if ((spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3)
+    || (spec[0] === 0 && spec.length !== 13)
+    || (spec[0] === 1 && spec.length !== 12)
+    || (spec[0] === 2 && spec.length < 6)
+    || (spec[0] === 3 && spec.length !== 3)) {
+    throw new TypeError('table lexical program has an invalid fixed body width')
+  }
+  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
+    throw new TypeError('table lexical program semantic digest is inconsistent')
+  }
+  if (spec[0] === 3) {
+    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
+      throw new TypeError('table balanced lexical program has an invalid scan reference')
+    }
+    const run: LexProgramRunner = (_input, _pos, ctx, scan) => {
+      if (scan === undefined) throw new TypeError('table balanced lexical program lost its scan body')
+      const result = scan.parse(_input, _pos, ctx)
+      if (!result.ok) {
+        ctx._fe = result.span.start
+        ctx._fx = (result.expected ?? []) as string[]
+        return -1
+      }
+      return result.span.end
+    }
+    return Object.assign(run, { scan: spec[2] })
+  }
+  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected)
+  if (spec[0] === 1) {
+    const g00 = matchers[spec[2]], g01 = matchers[spec[3]]
+    const g02 = matchers[spec[4]], g03 = matchers[spec[5]]
+    const guard0Fx = expected[spec[6]]
+    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]]
+    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]]
+    const tracks = spec[11]
+    if (g00 === undefined || g01 === undefined || g02 === undefined || g03 === undefined
+      || guard0Fx === undefined || g1 === undefined || guard1Fx === undefined
+      || terminal === undefined || terminalFx === undefined || (tracks !== 0 && tracks !== 1)) {
+      throw new TypeError('table lexical program references an invalid pool entry')
+    }
+    return (input, pos, ctx) => {
+      ctx._fc = false
+      if (g00(input, pos) >= 0 || g01(input, pos) >= 0
+        || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
+        ctx._fe = pos
+        ctx._fx = guard0Fx as string[]
+        return -1
+      }
+      ctx._fc = false
+      if (g1(input, pos) >= 0) {
+        ctx._fe = pos
+        ctx._fx = guard1Fx as string[]
+        return -1
+      }
+      ctx._fc = false
+      const result = terminal(input, pos)
+      if (result < 0) {
+        ctx._fe = pos
+        ctx._fx = terminalFx as string[]
+        if (ctx._probe !== undefined) failAt(ctx, ctx._fx, pos)
+        return -1
+      }
+      const end = result / 2
+      if (tracks === 1) trackLexLines(ctx, input, end)
+      return end
+    }
+  }
+  const cls = classes[spec[2]]
+  const choiceFx = expected[spec[3]]
+  const m0 = matchers[spec[4]], x0 = expected[spec[5]]
+  const m1 = matchers[spec[6]], x1 = expected[spec[7]]
+  const m2 = matchers[spec[8]], x2 = expected[spec[9]]
+  const m3 = matchers[spec[10]], x3 = expected[spec[11]]
+  const tracks = spec[12]
+  if (cls === undefined || choiceFx === undefined
+    || m0 === undefined || x0 === undefined || m1 === undefined || x1 === undefined
+    || m2 === undefined || x2 === undefined || m3 === undefined || x3 === undefined
+    || (tracks !== 0 && tracks !== 1)) {
+    throw new TypeError('table lexical program references an invalid pool entry')
+  }
+
+  return (input, pos, ctx) => {
+    const lead = pos < input.length ? input.codePointAt(pos)! : -1
+    if (!classHas(cls, lead)) {
+      ctx._fe = pos
+      ctx._fx = choiceFx.slice()
+      return -1
+    }
+    let acc: string[] | undefined
+    const failed = (fx: readonly string[]): void => {
+      ctx._fe = pos
+      ctx._fx = fx as string[]
+      if (ctx._probe !== undefined) failAt(ctx, ctx._fx, pos)
+      if (acc === undefined) acc = fx.slice()
+      else acc.push(...fx)
+    }
+    ctx._fc = false
+    const success = (result: number): number => {
+      const end = result / 2
+      if (tracks === 1) trackLexLines(ctx, input, end)
+      return end
+    }
+    let result = m0(input, pos)
+    if (result >= 0) return success(result)
+    failed(x0)
+    ctx._fc = false
+    result = m1(input, pos)
+    if (result >= 0) return success(result)
+    failed(x1)
+    ctx._fc = false
+    result = m2(input, pos)
+    if (result >= 0) return success(result)
+    failed(x2)
+    ctx._fc = false
+    result = m3(input, pos)
+    if (result >= 0) return success(result)
+    failed(x3)
+    ctx._fe = pos
+    ctx._fx = acc ?? choiceFx as string[]
+    return -1
+  }
+}