parseman 0.57.0 → 0.58.0

package/src/table/child-slots.ts

@@ -1,5 +1,5 @@
 import {
-  OP_ADJ, OP_ARMGATE, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT,
+  OP_ADJ, OP_ARMGATE, OP_RGATE, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_DISPATCH, OP_EMPTY, OP_EXPECT,
   OP_FIELD, OP_GATE, OP_GREEDY, OP_GUARD, OP_LABEL, OP_LEAF, OP_SOURCE_LEAF, OP_LIT, OP_LIT_CI,
   OP_LIT_CI_TRACK, OP_LIT_TRACK, OP_LIVE, OP_NODE, OP_NODE_TRACK, OP_NOT, OP_OPT,
   OP_PEEK, OP_REJECT, OP_REP, OP_REPV, OP_ROUTED, OP_RULE, OP_RX, OP_RX_TRACK, OP_SCAN,
@@ -53,7 +53,7 @@ export function childSlots(code: ArrayLike<number>, ip: number, out: number[]):
 
     // Single child at `ip + 2`.
     case OP_GATE: case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM:
-    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_SOURCE_LEAF: case OP_ARMGATE:
+    case OP_NODE: case OP_NODE_TRACK: case OP_FIELD: case OP_LEAF: case OP_SOURCE_LEAF: case OP_ARMGATE: case OP_RGATE:
       out.push(code[ip + 2]!)
       return true
 

package/src/table/compile-rule-map.ts

@@ -369,18 +369,27 @@ export function compileRuleMap(
     // the selection is judged by the source it actually emits, scaled for that 5%,
     // and narrowed until that fits.
     const ceiling = budget / SUPERCOMPILE_GROWTH
+    // A budget that cannot cover the prelude buys nothing, by design: no refusal.
+    if (ceiling <= fixed) return none
+    // Narrowed until it fits, with no attempt limit: the target shrinks by at
+    // least 1% a round, so the selection either fits or empties. An empty one
+    // says why — a build that asked for an assembly and silently shipped none is
+    // a regression no test sees (the artifact still parses, on the closures).
     let target = ceiling
-    for (let attempt = 0; attempt < 16; attempt++) {
+    for (;;) {
       const sites = selectHotSites(artifact.code, Object.values(artifact.rules), siteBytes, target - fixed, profile)
-      if (sites.size === 0) return none
+      if (sites.size === 0) {
+        return {
+          ...none,
+          refusal: `a site within its ${Math.floor(ceiling)} B selection ceiling (the prelude alone is ${fixed} B)`,
+        }
+      }
       const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites).source.length
       if (bytes <= ceiling) return { sites, bytes: Math.ceil(bytes * SUPERCOMPILE_GROWTH) }
       // Scale by the overshoot, and by at least 1%: near the ceiling a site is
-      // the unit, and the ratio alone can stall a few bytes over it until the
-      // attempts run out and nothing ships.
+      // the unit, and the ratio alone can stall a few bytes over it.
       target *= Math.min(ceiling / bytes, 0.99)
     }
-    return none
   }
 
   return {

package/src/table/emit-assembly.ts

@@ -47,7 +47,7 @@
 import type { ParseContext } from '../types.ts'
 import { regexCanMatchEmpty } from '../regex/first-set.ts'
 import {
-  OP_ADJ, OP_ARMGATE, OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE,
+  OP_ADJ, OP_ARMGATE, OP_RGATE, OP_ATTEMPT, OP_CHOICE, OP_DISPATCH, OP_EMPTY, OP_EXPECT, OP_FIELD, OP_GATE,
   OP_LABEL, OP_LEAF, OP_SOURCE_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_SCOPE_PLAIN, OP_SEQ, OP_SEQV, OP_SEQX, OP_TOKEN, OP_WITHCTX, OP_XFORM,
@@ -60,13 +60,14 @@ import {
 import { emitShapeMatch, scanShapeFromRegex } from './scan-shapes.ts'
 import {
   CAP_OFF, CAP_ON, RAW_CAPTURE, RAW_OMIT, TRI_NONE, TRI_UNKNOWN,
-  computeSiteLabels, reachableSites, type SiteLabel,
+  computeSiteLabels, gatedPassCollapse, passCollapse, reachableSites, scopeIsIdentity, triviaLeadRanges, type SiteLabel,
 } from './site-labels.ts'
 import {
   largeChoiceLiteralPretest, leadingScalarSequence, leadingScalarTerminal,
-  scalarTerminalNodeChild, scalarTerminalNotChild, type LeadingScalarSequence,
+  scalarTerminalNodeChild, scalarTerminalNotChild, scalarTerminalPeekChild, type LeadingScalarSequence,
 } from './scalar-terminal.ts'
 import { childSlots } from './child-slots.ts'
+import { holdsGap } from './hold-gap.ts'
 import { fieldSpec, leadingTriviaFieldAt } from './field-spec.ts'
 import { FIELD_LEADING_TRIVIA, FIELD_TRAILING_TRIVIA } from '../combinators/field-trivia.ts'
 
@@ -138,6 +139,9 @@ export const EMITTED_PARAMS = [
   // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
   // factories ignore it.
   'skipDeferredTrivia',
+  // Appended for the pass-through collapse (`run-support.ts`); old factories
+  // ignore it.
+  'collapseEmpty',
 ] as const
 
 /**
@@ -436,6 +440,30 @@ ${scanned}
 }`
 }
 
+/**
+ * A lookahead term that HOLDS its gap (`hold-gap.ts`): the gap is scanned and
+ * kept, the lookahead runs at its end, and the cursor stays there for the next
+ * term, which cannot match empty.
+ */
+function emitHoldTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string): 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 held = `const ${t}s=${skip}(input,cur,ctx)
+const ${t}v=${callee}(input,${t}s,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+cur=${t}s`
+  if (l.tri !== TRI_UNKNOWN) return held
+  return `if(ctx.trivia===undefined){
+${fast}
+}else{
+${held}
+}`
+}
+
 /**
  * The repetition's LEAD-TRIVIA skip, as a BLOCK.
  *
@@ -603,6 +631,8 @@ export function emitAssemblySource(
   // the closure recognizer pool: distinct terminal rows sharing one spec share
   // both the recognizer and the ordinary-terminal lowering.
   const scalarSpecs = new Set<number>()
+  // Row nullability for `holdsGap`, memoised for this emit.
+  const nullable = new Map<number, boolean>()
   // Large choices are different: admitting every wrapped scalar would add a
   // recognizer call to many arms whose one-character gate already did all the
   // useful work. A multi-character literal can still refine an overlapping
@@ -1115,17 +1145,9 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)\n` : ''}return FAIL
     // The label is what makes this decidable: `tri >= 0` can ONLY have come from
     // an enclosing 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. `OP_SCOPE_PLAIN` has no root
-    // policy by construction; a policy-bearing `OP_SCOPE` aliases only when its
-    // literal policy is zero. `OP_SCOPE_CAP` also raises `captureTrivia`.
-    //
-    // `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_PLAIN || (op === OP_SCOPE && code[ip + 3]! === 0)) && code[ip + 1]! >= 0
-      && labels.at(ip).tri === code[ip + 1]!) {
-      return code[ip + 2]!
-    }
+    // already the values this row would write. A scope with no trivia under
+    // `TRI_NONE` is the same case (`scopeIsIdentity`).
+    if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2]!
     return undefined
   }
 
@@ -1325,6 +1347,23 @@ return ${child}(input,pos,ctx)
 }`
       }
 
+      case OP_RGATE: {
+        const child = link(code[ip + 2]!)
+        if (cfg.tolerant || cfg.probe) return `${head}
+return ${child}(input,pos,ctx)
+}`
+        const resolved = t.cc[code[ip + 1]!]!
+        const ci = classes.push([resolved]) - 1
+        classPlan.push([code[ip + 1]!])
+        const cls = hoist('cl', `CLS[${ci}][0]`)
+        const xf = fxRef(code[ip + 3]!)
+        return `${head}
+const it=ctx._routed
+if(it!==undefined&&it.span.start===pos&&!classHas(${cls},lead(input,it.span.end))){ctx._fe=it.span.end;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`
+      }
+
       case OP_ARMGATE: {
         // `choice({ gate, combinator })`, as `assemble.ts` lowers it. A blocked
         // arm is SKIPPED, not failed (choice.ts `continue`): it clears the cut,
@@ -1663,9 +1702,9 @@ return FAIL
         const p = tmp()
         return `${head}
 ${lookaheadMiss(code[ip + 1]!, 'EC.e=pos;return null')}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? 'const pb=ctx._probe?.best\n' : ''}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){EC.e=pos;return null}
+${cfg.probe ? 'if(ctx._probe!==undefined)ctx._probe.best=pb??null\n' : ''}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
 return FAIL
@@ -1673,14 +1712,24 @@ return FAIL
       }
 
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip)
+        if (scalarChild >= 0) {
+          const recognize = recognizerRef(code[scalarChild + 1]!)
+          const xf = fxRef(code[ip + 2]!)
+          return `${head}
+if(${recognize}(input,pos)<0){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+EC.e=pos
+return null
+}`
+        }
         const child = link(code[ip + 1]!)
         const xf = fxRef(code[ip + 2]!)
         const p = tmp()
         return `${head}
 ${lookaheadMiss(code[ip + 1]!, `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${cfg.probe ? 'const pb=ctx._probe?.best\n' : ''}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+${cfg.probe ? 'if(ctx._probe!==undefined)ctx._probe.best=pb??null\n' : ''}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
 }`
@@ -1779,7 +1828,9 @@ return v
             // The callee expression hands it over AFTER the scan statement, right
             // before the call, so a field inside the trivia grammar cannot take it.
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]!})` : kids[i]!
-            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)))
+            parts.push(holdsGap(code, k, base, n, i, nullable)
+              ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L))
+              : emitTerm(callee, vn, tmp(), L, skipFor(L)))
           }
           names.push(vn)
         }
@@ -2433,6 +2484,35 @@ return nd
         // The trailing-trivia bit (128) rides on the children-only shape as it
         // does in the closure assembler: a consume after the body, no capture.
         const leanFlags = flags & ~128
+        // THE PASS-THROUGH COLLAPSE (`run-support.ts` `collapseEmpty`): a
+        // collapse over one node is that node. `passCollapse` is the closure
+        // engine's test too.
+        if (build !== undefined && passCollapse(code, ip, hostCst)) {
+          return `${head}
+const v=${child}(input,pos,ctx)
+if(v!==undefined)return v
+return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
+}`
+        }
+        // A GATED PASS COLLAPSE (`site-labels.ts` `gatedPassCollapse`): where the
+        // character at `pos` opens none of the body's optional terms and no
+        // trivia, the body is its node term, run as a pass-through collapse.
+        // Not under recovery or a probe: there a gated-out term still runs.
+        const gated = build !== undefined && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : undefined
+        const triviaLead = gated === undefined ? undefined : triviaLeadRanges(labels.at(code[ip + 2]!).tri, t.trivia)
+        const gp = gated !== undefined && triviaLead !== undefined && triviaLead.length <= 16
+          ? `const gc=lead(input,pos)
+if(!(${[
+  ...gated.leads.map(g => `!(${gateMissTest(g)})`),
+  ...gated.lits.map(i => `gc===${(k[i] as string).codePointAt(0)!}`),
+  ...triviaLead.map(r => r.lo === r.hi ? `gc===${r.lo}` : `(gc>=${r.lo}&&gc<=${r.hi})`),
+].join('||') || 'false'})){
+const gv=${link(gated.last)}(input,pos,ctx)
+if(gv!==undefined)return gv
+return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
+}
+`
+          : ''
         if (!hostCst && !tracked && build !== undefined && proj < 0
           && (leanFlags === 2 || (flags === 18 || flags === 34))) {
           const fields = flags === 18
@@ -2470,7 +2550,7 @@ sCh.push(nd)
 if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
 }`
           return `${head}
-const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${gp}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf,sFields=ctx._fields
 const flat=[]
 ctx._cstBuf=undefined
@@ -2565,7 +2645,7 @@ 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
+${!hostCst && !tracked ? gp : ''}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
 ${openCapture}
 ctx.captureTrivia=${captureWide}
@@ -2656,10 +2736,19 @@ bind:function(xs,ps){_xScan=xs
 ${externals.map((ip, i) => `_xp${ip}=ps[${i}]`).join('\n')}},
 scan:function(s){const o=_pfScan;_pfScan=s;return o}`
   // One wrapper per external: the closure engine reads its OWN installed trivia
-  // scanner, so the emitted one is handed across for the call and restored.
+  // scanner, so the emitted one is handed across for the call and restored. A
+  // site whose label names its trivia hands that trivia's own scanner, which is
+  // what any scope installing it would have installed: the emitted slot is read
+  // only where the labels cannot say (`site-labels.ts` `scanHandoffNeeded`).
+  const scannerFor = (ip: number): string => {
+    const ki = labels.at(ip).tri
+    if (ki === TRI_UNKNOWN) return '_pfScan'
+    if (ki === TRI_NONE) return 'null'
+    return swapLegal && !triviaLabelled[ki]! && t.triviaScan[ki] != null ? hoist('ts', `TRIVIASCAN[${ki}]`) : 'null'
+  }
   const externalDefs = select === undefined ? '' : `let _xScan
 ${externals.map(ip => `let _xp${ip}
-function _px${ip}(input,pos,ctx){const o=_xScan(_pfScan);const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join('\n')}
+function _px${ip}(input,pos,ctx){const o=_xScan(${scannerFor(ip)});const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join('\n')}
 `
 
   // The per-label trivia scans sit AFTER the hoisted pool they close over: they

package/src/table/emit.ts

@@ -35,7 +35,9 @@ function emitClassPool(classes: readonly string[]): string {
   if (classes.length < 2) return array
   const delimiter = '|/~?^`'.split('').find(ch => classes.every(spec => !spec.includes(ch)))
   if (delimiter === undefined) return array
-  const split = `${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`
+  // A call a bundler cannot prove pure is kept even when nothing reads its result,
+  // so a sibling variant shaken out of a bundle left its whole pool behind.
+  const split = `/* @__PURE__ */ ${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`
   return split.length < array.length ? split : array
 }
 

package/src/table/encode.ts

@@ -1,4 +1,5 @@
 import { scanRefs } from './program.ts'
+import { factorSharedEnds } from './factor-choice.ts'
 import type { AutoNotCheck, Combinator, FirstSet, ParserDef } from '../types.ts'
 import { classifyFinalChoice, firstSetOf, intersects, matchesEmpty, union, type RefResolver } from '../combinators/first-set.ts'
 import { childrenOf } from '../analysis/gating.ts'
@@ -16,7 +17,7 @@ import {
   OP_LIT_TRACK, OP_RX_TRACK, OP_NODE_TRACK, OP_SCOPE, OP_SCOPE_CAP, OP_SCOPE_PLAIN, OP_EXPECT, OP_SEQX, OP_SCAN,
   OP_LIVE, OP_ATTEMPT, OP_LABEL,
   OP_FIELD, OP_DISPATCH, OP_ROUTED, OP_LIT_CI, OP_LIT_CI_TRACK, OP_TOKEN, OP_WITHCTX, OP_GUARD,
-  OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_COV,
+  OP_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE, OP_COV,
   OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
 import { adjacencyExpected } from '../combinators/adjacency.ts'
@@ -27,8 +28,8 @@ import type { BalancedSpec } from '../combinators/scanTo.ts'
 import type { DispatchSpec, LexBodySpec, LexProgramSpec, ScanSpec, SubtreeRef, TableProgram, TriviaSpec } from './program.ts'
 import {
   lexProgramDigest,
-  LEX_NODE_CHOICE2, LEX_NODE_CHOICE4, LEX_NODE_CHOICE8,
-  LEX_NODE_NOT, LEX_NODE_OPTIONAL,
+  LEX_NODE_CHOICE,
+  LEX_NODE_NOT, LEX_NODE_OPTIONAL, LEX_NODE_REPEAT,
   LEX_NODE_SEQUENCE2, LEX_NODE_SEQUENCE3, LEX_NODE_SEQUENCE4, LEX_NODE_SEQUENCE5,
   LEX_NODE_TERMINAL,
 } from './lex-program.ts'
@@ -298,15 +299,18 @@ class Encoder {
           }
           case 'choice': {
             for (const arm of node.arms) if (!emitNode(arm)) return false
-            const op = node.arms.length === 2 ? LEX_NODE_CHOICE2
-              : node.arms.length === 4 ? LEX_NODE_CHOICE4
-                : node.arms.length === 8 ? LEX_NODE_CHOICE8 : -1
-            if (op < 0) return false
-            words.push(op, this.expected(node.expected))
+            // The arm classes and the exclusive (one-arm) decision are the
+            // character choice's own (`case 'choice'`), under the trivia the
+            // encoder would hold at that row, so both lowerings rank the same
+            // failures.
+            const final = classifyFinalChoice(
+              node.parsers, this.refResolver(), node.cleared ? undefined : this.activeTrivia,
+            )
+            const classes = final.firstSets.map((first, i) => final.nullable[i] ? -1 : this.charClass(first))
+            const exclusive = final.exclusive && classes.every(cls => cls >= 0)
+            words.push(LEX_NODE_CHOICE, node.arms.length, exclusive ? 1 : 0, this.expected(node.expected))
             for (let i = 0; i < node.arms.length; i++) {
-              const first = node.firstSets[i]!
-              words.push(first.kind === 'ranges' ? this.charClass(first) : -1)
-              words.push(this.expected(node.armExpected[i]!))
+              words.push(classes[i]!, this.expected(node.armExpected[i]!))
             }
             return true
           }
@@ -318,6 +322,10 @@ class Encoder {
             if (!emitNode(node.body)) return false
             words.push(LEX_NODE_OPTIONAL)
             return true
+          case 'repeat':
+            if (!emitNode(node.body)) return false
+            words.push(LEX_NODE_REPEAT, node.min, node.max)
+            return true
         }
       }
       if (!emitNode(body.root)) return undefined
@@ -940,6 +948,54 @@ class Encoder {
     return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip)
   }
 
+  /**
+   * The `OP_RGATE` operands of a choice arm that opens with `routed()`, or
+   * `undefined`. Through `node()`/scope wrappers and first sequence terms, the
+   * arm's next term after the routed token is found; the gate is that term's
+   * first characters, with the trivia in force at the boundary before it, so
+   * the arm is entered only where it can get past the token. The term must be
+   * unable to match empty or to commit, so a miss is exactly that term failing
+   * at the token's end with its own set.
+   */
+  private routedArmGate(arm: Combinator<unknown>): { cls: number; fx: number } | undefined {
+    type Follow = 'end' | { next: Combinator<unknown>; boundary: Combinator<unknown> | undefined } | undefined
+    const walk = (p: Combinator<unknown>, trivia: Combinator<unknown> | undefined, depth: number): Follow => {
+      if (depth > 16) return undefined
+      const d = p._def as ParserDef
+      switch (d.tag) {
+        case 'routed': return 'end'
+        case 'node': return walk(d.parser, trivia, depth + 1)
+        case 'grammar':
+          return walk(d.parser, d.clearTrivia === true ? undefined : d.triviaParser ?? trivia, depth + 1)
+        case 'sequence': {
+          const head = d.parsers[0]
+          if (head === undefined) return undefined
+          const r = walk(head, trivia, depth + 1)
+          if (r !== 'end') return r
+          const next = d.parsers[1]
+          return next === undefined ? 'end' : { next, boundary: trivia }
+        }
+        default: return undefined
+      }
+    }
+    const follow = walk(arm, this.activeTrivia, 0)
+    if (follow === undefined || follow === 'end') return undefined
+    const rr = this.refResolver()
+    const { next, boundary } = follow
+    if (matchesEmpty(next, new Set(), rr) || mayCommitFailure(next, rr, this.commitFailureMemo)) return undefined
+    // A miss reports `deriveExpected(next)`, a static set. Only a terminal or a
+    // label fails with exactly that set: a sequence over an `optional` prefix
+    // reports the prefix's labels statically but not when it runs, and a choice
+    // whose arms share an opener reports that opener once statically, once per
+    // arm when it runs.
+    const nextTag = (next._def as ParserDef).tag
+    if (nextTag !== 'literal' && nextTag !== 'regex' && nextTag !== 'keywords' && nextTag !== 'label') return undefined
+    const first = firstSetOf(next, new Set(), rr, boundary)
+    const cls = this.charClass(boundary === undefined ? first : union(first, firstSetOf(boundary, new Set(), rr)))
+    if (cls < 0) return undefined
+    return { cls, fx: this.expected(deriveExpected(next)) }
+  }
+
   node(p: Combinator<unknown>): Emitted {
     // See `refMemo`: a reference is memoised per REFERENCING trivia scope, every
     // other construct once for the program.
@@ -1101,6 +1157,12 @@ class Encoder {
         return head
       }
       case 'choice': {
+        // Arms that differ in one term are that term's choice (`factor-choice.ts`).
+        // Not under a coverage plan, which credits the arms as written.
+        if (this.plan === undefined) {
+          const factored = factorSharedEnds(d)
+          if (factored !== undefined) return this.node(factored).ip
+        }
         // `greedyClassify` is NOT a choice at all — one arm runs and another arm
         // is credited — so it gets its own row rather than an arm ordering.
         if (d.strategy.tag === 'greedyClassify') {
@@ -1169,11 +1231,15 @@ class Encoder {
         const kids = arms.map((c, k) => {
           const src = order[k]!
           const checks = d.autoNot[src]
-          const inner = this.node(c).ip
+          const gate = d.gates[src]
+          const plain = (checks === null || checks === undefined || checks.length === 0)
+            && (gate === null || gate === undefined)
+          const routedGate = plain ? this.routedArmGate(c) : undefined
+          const body = this.node(c).ip
+          const inner = routedGate === undefined ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx)
           const ip = checks === null || checks === undefined || checks.length === 0
             ? inner
             : this.reject(inner, checks)
-          const gate = d.gates[src]
           const gated = gate === null || gate === undefined
             ? ip
             : this.emit(OP_ARMGATE, this.fn(gate, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)))
@@ -1794,7 +1860,7 @@ class Encoder {
     }
     const slots = (ip: number): number[] => {
       switch (this.code[ip]) {
-        case OP_GATE: return [ip + 2]
+        case OP_GATE: case OP_RGATE: return [ip + 2]
         case OP_RULE: case OP_OPT: case OP_NOT: case OP_PEEK: case OP_EXPECT: case OP_ATTEMPT: case OP_LABEL: case OP_COV: return [ip + 1]
         case OP_SCOPE: case OP_SCOPE_CAP: case OP_SCOPE_PLAIN: case OP_WITHCTX: case OP_XFORM: case OP_LEAF: case OP_SOURCE_LEAF: case OP_NODE: case OP_NODE_TRACK: return [ip + 2]
         case OP_SEQ: case OP_SEQV: return Array.from({ length: this.code[ip + 1]! }, (_, i) => ip + 2 + i)

package/src/table/exec.ts

@@ -22,7 +22,7 @@ import {
   OP_LIVE,
   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_ADJ, OP_GREEDY, OP_REJECT, OP_ARMGATE, OP_RGATE,
   OP_LEX_BODY, OP_LEX_PROGRAM,
 } from './ops.ts'
 import { adjacencyHolds, adjacencyMisuse } from '../combinators/adjacency.ts'
@@ -49,7 +49,7 @@ import {
   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'
+import { scalarTerminalNotChild, scalarTerminalPeekChild } from './scalar-terminal.ts'
 
 /**
  * THE SHARED DRIVER.
@@ -923,6 +923,7 @@ function makeDriver(
             const lit = k[code[child + 1]!] as string
             if (!input.startsWith(lit, cur)) {
               ctx._fe = cur; ctx._fx = fx[code[child + 2]!] as string[]
+              if (ctx._probe !== undefined) failAt(ctx, ctx._fx, cur)
               { if (REC) ctx._sync = inheritedSync; return FAIL }
             }
             const e = cur + lit.length
@@ -937,6 +938,7 @@ function makeDriver(
             const m = re.exec(input)
             if (m === null) {
               ctx._fe = cur; ctx._fx = fx[code[child + 2]!] as string[]
+              if (ctx._probe !== undefined) failAt(ctx, ctx._fx, cur)
               { if (REC) ctx._sync = inheritedSync; return FAIL }
             }
             const mv = m[0]
@@ -1118,6 +1120,16 @@ function makeDriver(
         return sup
       }
 
+      case OP_RGATE: {
+        const item = ctx._routed
+        if (item !== undefined && item.span.start === pos && ctx._probe === undefined && !ctx._tolerant
+          && !classHas(cc[code[ip + 1]!]!, lead(input, item.span.end))) {
+          ctx._fe = item.span.end; ctx._fx = fx[code[ip + 3]!] as string[]
+          return FAIL
+        }
+        return exec(code[ip + 2]!, input, pos, ctx)
+      }
+
       case OP_ARMGATE: {
         if (!(fns[code[ip + 1]!] as (s: unknown) => boolean)(ctx.state)) {
           // choice.ts:150 is a `continue`, not a failure — the arm is treated as
@@ -1574,15 +1586,14 @@ 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.
+        // The generic closure/emitted NOT bodies leave the child's failure
+        // registers; only the direct-terminal shape hides them. Every NOT hides
+        // the child's completions from the probe, as `not.ts` does.
         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 savedProbe = ctx._probe?.best
         const need = rollbackNeeded(ctx)
         const mRaw = need ? cstRawLen(ctx) : 0
         const mTl = need ? cstTlLen(ctx) : 0
@@ -1597,8 +1608,8 @@ function makeDriver(
           ctx._fc = savedFc
           ctx._fe = savedFe
           ctx._fx = savedFx
-          if (ctx._probe !== undefined) ctx._probe.best = savedProbe ?? null
         }
+        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
@@ -1607,6 +1618,12 @@ function makeDriver(
       }
 
       case OP_PEEK: {
+        // A direct terminal is reduced to its recognizer in both assemblies
+        // (`scalarTerminalPeekChild`), as under `not()`: hide its own diagnostic
+        // writes here too.
+        const scalarChild = scalarTerminalPeekChild(code, ip) >= 0
+        const savedFc = scalarChild ? ctx._fc : false
+        const savedProbe = ctx._probe?.best
         const need = rollbackNeeded(ctx)
         const mRaw = need ? cstRawLen(ctx) : 0
         const mTl = need ? cstTlLen(ctx) : 0
@@ -1617,6 +1634,8 @@ 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
+        if (ctx._probe !== undefined) ctx._probe.best = savedProbe ?? null
         // `peek.ts:60` — the ASSERTION's own set, at the assertion's position.
         if (v === FAIL) { ctx._fe = pos; ctx._fx = fx[code[ip + 2]!] as string[]; return FAIL }
         EC.e = pos