parseman 0.56.0 → 0.58.0

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,12 +28,12 @@ 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'
-import { covKindCode, encodeClassSpec, ownTableProgram } from './program.ts'
+import { covKindCode, dispatchIsExclusive, encodeClassSpec, ownTableProgram } from './program.ts'
 import type { GrammarCoveragePlan } from '../compiler/grammar-coverage-ids.ts'
 import { directArrayProjection } from '../compiler/direct-projection.ts'
 import {
@@ -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
@@ -699,6 +707,38 @@ class Encoder {
     }
   }
 
+  /**
+   * THE FIRST-CHARACTER GATE OF AN `optional`, `not` OR `peek` CHILD.
+   *
+   * A non-nullable child cannot match at a character outside its first set, so
+   * the wrapper's outcome there is already decided: `optional` yields `null`,
+   * `not` succeeds, `peek` fails with its own set. The interpreter's `optional`
+   * makes that test itself (`repeat.ts` `startsFirstSet`); the table entered the
+   * child — a rollback mark, the call, the child's own failure — to learn it.
+   *
+   * The gate is an `OP_GATE` row around the child, so every engine runs it
+   * unchanged, a probe or tolerant parse forwards through it as for a node's
+   * gate, and the wrapper's row keeps its layout. The engines test the class
+   * before taking the wrapper's mark. The first set is resolved through
+   * `winners`, the analysis a choice arm's gate uses, so a composed rule's set
+   * is the merged one. A scalar `not` child stays bare: `scalarTerminalNotChild`
+   * already reduces it to one recognizer call.
+   */
+  private lookaheadGate(p: Combinator<unknown>, child: number): number {
+    // By opcode FAMILY: a line-tracked variant spells the same terminal
+    // `OP_LIT_TRACK`/`OP_RX_TRACK`, and every variant of one grammar must lay
+    // down the same words (`foldPrograms`).
+    const op = this.code[child]
+    if (op === OP_GATE || op === OP_LIT || op === OP_LIT_CI || op === OP_LIT_TRACK || op === OP_LIT_CI_TRACK
+      || op === OP_RX || op === OP_RX_TRACK) return child
+    const rr = this.refResolver()
+    if (matchesEmpty(p, new Set(), rr)) return child
+    const cls = this.charClass(firstSetOf(p, new Set(), rr, this.activeTrivia))
+    if (cls < 0) return child
+    const e = deriveExpected(p)
+    return this.emit(OP_GATE, cls, child, this.expected(e.length > 0 ? e : [p._tag]))
+  }
+
   /** A first set becomes a char class string, or −1 for `any`. */
   private charClass(fs: FirstSet): number {
     if (fs.kind !== 'ranges' || fs.ranges.length === 0) return -1
@@ -715,14 +755,21 @@ class Encoder {
     return i
   }
 
-  /** Bind a guard only when its class is already part of the program. Repeat
-   * gating must not grow the compact artifact merely to avoid a failed call. */
-  private existingCharClass(fs: FirstSet): number {
-    if (fs.kind !== 'ranges' || fs.ranges.length === 0) return -1
-    const hit = this.ccIndex.get(encodeClassSpec(fs.ranges))
-    // This reuses the recovery row's existing `-1` slot. Keep its decimal width
-    // at two bytes or less so a speed hint cannot grow a compact artifact.
-    return hit !== undefined && hit < 100 ? hit : -1
+  /**
+   * The first set a node's or an attempt's fail-fast gate tests. A bare
+   * cross-rule ref resolves through `winners` (a compose OVERRIDE may widen
+   * it). Any other body keeps its construction-time `_meta.firstSet`, except
+   * where that is `any`: under `compose()` a body that reaches a rule of
+   * another piece is built before that rule exists, so its cached set is
+   * `any` and the node got NO gate (jess's `CompoundSelector` was entered at
+   * `{`, `Call` at `}`). The resolved set is the one a choice arm's gate uses,
+   * over the final merged map.
+   */
+  private gateFirstSet(p: Combinator<unknown>): FirstSet {
+    const cached = p._meta.firstSet
+    return p._def.tag === 'lazy' || cached.kind === 'any'
+      ? firstSetOf(p, new Set(), this.refResolver(), this.activeTrivia)
+      : cached
   }
 
   /**
@@ -901,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.
@@ -1062,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') {
@@ -1130,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)))
@@ -1202,6 +1307,19 @@ class Encoder {
             if (transactionalFirst[i] !== undefined) classes[i] = -1
           }
         }
+        // A STATE-GATED ARM ON THE ORDERED PATH IS ALWAYS ENTERED. The interpreter
+        // skips a gated-off arm and contributes nothing for it (choice.ts
+        // firstMatch), and gates it on only by running it. A char-gated skip would
+        // instead add the arm's static opener set whatever the gate says, so an
+        // ordered site leaves the decision to `OP_ARMGATE`. An exclusive site keeps
+        // its classes: there the dispatched arm's gate failing IS the choice
+        // failing, with that arm's set, as in the interpreter's disjoint path.
+        if (d.gates.some(g => g !== null && g !== undefined) && !dispatchIsExclusive(classes, this.cc)) {
+          for (let k = 0; k < classes.length; k++) {
+            const gate = d.gates[order[k]!]
+            if (gate !== null && gate !== undefined) classes[k] = -1
+          }
+        }
         const dispIdx = this.disp.length
         this.disp.push(classes)
         // PER-ARM EXPECTED SETS RIDE ALONG, after the arm offsets. While the best
@@ -1245,7 +1363,7 @@ class Encoder {
         const rr = this.refResolver()
         const itemClass = matchesEmpty(d.parser, new Set(), rr)
           ? -1
-          : this.existingCharClass(firstSetOf(d.parser, new Set(), rr, this.activeTrivia))
+          : this.charClass(firstSetOf(d.parser, new Set(), rr, this.activeTrivia))
         const op = d.valueUnused ? OP_REPV : OP_REP
         const min = d.tag === 'many' ? 0 : d.min
         // ip + 6 is the ITEM's expected set and ip + 7 the separator's sentinel
@@ -1288,7 +1406,7 @@ class Encoder {
           : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags)
       }
       case 'optional': {
-        const head = this.emit(OP_OPT, this.node(d.parser).ip)
+        const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip))
         if (!this.failureNeedsRollback(d.parser, undefined)) this.failureRollbackCleanSites.add(head)
         return head
       }
@@ -1409,16 +1527,14 @@ class Encoder {
         // `deriveExpected(body)`, which for a body with nullable leading terms
         // names tokens the run would have skipped — `['"@"', '"(", '"x"']` where
         // running the body reports `['"x"']` alone.
-        if (matchesEmpty(d.parser)) return body
+        if (matchesEmpty(d.parser, new Set(), this.refResolver())) return body
         // A node whose BODY is a bare cross-rule ref (`node('X', g.Y, …)`) caches its
         // first set from the ref's base binding. Under a compose OVERRIDE the winner
         // for `Y` may be WIDER, so the cached set gates out input the merged rule
         // accepts (the reducer reroutes via `winners`, but this recognizer gate did
         // not). Resolve the ref's gate through `winners`, exactly as the `lazy` case
         // resolves the call. Non-ref bodies keep the cached set (byte-identical).
-        const fs = d.parser._def.tag === 'lazy'
-          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
-          : d.parser._meta.firstSet
+        const fs = this.gateFirstSet(d.parser)
         if (fs.kind === 'any') return body
         const cls = this.charClass(fs)
         if (cls < 0) return body
@@ -1558,7 +1674,7 @@ class Encoder {
       // other engine reported `['not(literal)']`. It hid because `expected` is a
       // TOP-LEVEL field on `RunResult` and is NOT part of the identity digest.
       case 'not':
-        return this.emit(OP_NOT, this.node(d.parser).ip, this.expected(assertionFailureExpected(false, d.parser._tag)))
+        return this.emit(OP_NOT, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(false, d.parser._tag)))
       case 'guard':
         // `'gate'`, the public name — see gate.ts. The def tag stays `'guard'`.
         return this.emit(OP_GUARD, this.fn(d.predicate, d.predSrc ?? null), this.expected(['gate']))
@@ -1603,7 +1719,7 @@ class Encoder {
         // lookahead's failure is "the guard did not hold", and naming the body's
         // internals offers a token the parse never asked the author for. The
         // table propagated the body's set instead.
-        return this.emit(OP_PEEK, this.node(d.parser).ip, this.expected(assertionFailureExpected(true, d.parser._tag)))
+        return this.emit(OP_PEEK, this.lookaheadGate(d.parser, this.node(d.parser).ip), this.expected(assertionFailureExpected(true, d.parser._tag)))
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case 'attempt': {
@@ -1619,10 +1735,8 @@ class Encoder {
         // not a slower equivalent.
         // Same override-aware resolution as the node gate: a bare-ref inner resolves
         // its gate through `winners` so a widened winner is not gated out.
-        const fs = d.parser._def.tag === 'lazy'
-          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
-          : d.parser._meta.firstSet
-        if (fs.kind === 'any' || matchesEmpty(d.parser)) return inner
+        const fs = this.gateFirstSet(d.parser)
+        if (fs.kind === 'any' || matchesEmpty(d.parser, new Set(), this.refResolver())) return inner
         const cls = this.charClass(fs)
         if (cls < 0) return inner
         const e = deriveExpected(d.parser)
@@ -1746,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-baseline.ts

@@ -487,9 +487,7 @@ function makeDriver(
           children: readonly unknown[], fields: undefined, span: { start: number; end: number },
           rawChildren: readonly unknown[], triviaLog: readonly number[], state: unknown,
         ) => unknown
-        const st = (flags & 8) !== 0 && ctx.state !== undefined
-          ? Object.assign({}, ctx.state as Record<string, unknown>)
-          : undefined
+        const st = (flags & 8) !== 0 ? ctx.state : undefined
         const nd = build(
           cap.children, undefined,
           code[ip] === OP_NODE_TRACK ? spanLines(ctx, pos, end) : { start: pos, end },

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,12 +1120,25 @@ 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
           // never entered, so a cut it might have raised must not cut the choice.
           ctx._fc = false
-          ctx._fe = pos
+          // No failure POSITION: an ordered choice ranks arms by `_fe`, and a skipped
+          // arm must not rank. A dispatched choice reads `_fx` alone, so this arm's
+          // set is still the answer when it is the one selected.
+          ctx._fe = -1
           ctx._fx = fx[code[ip + 3]!] as string[]
           return FAIL
         }
@@ -1479,9 +1494,7 @@ function makeDriver(
         if (v === FAIL) return FAIL
         const end = EC.e
         const span = code[ip] === OP_NODE_TRACK ? spanLines(ctx, pos, end) : { start: pos, end }
-        const st = (flags & 8) !== 0 && ctx.state !== undefined
-          ? Object.assign({}, ctx.state as Record<string, unknown>)
-          : undefined
+        const st = (flags & 8) !== 0 ? ctx.state : undefined
         const tagIdx = code[ip + 6]!
         const tags = tagIdx < 0 ? undefined : k[tagIdx] as readonly string[]
 
@@ -1518,13 +1531,13 @@ function makeDriver(
           nd = kids[0]
         } else if (proj >= 0) {
           nd = hostCst && host !== undefined
-            ? host(type, kids, fieldMap, span, cap.rawChildren, cap.triviaLog, (flags & 8) !== 0 ? st : ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined, tags)
+            ? host(type, kids, fieldMap, span, cap.rawChildren, cap.triviaLog, ctx.state, tags)
             : projectChild(kids, proj, type)
         } else if (buildIdx >= 0) {
           if (hostCst && host !== undefined) {
             // A direct builder is bypassed under a CST host: the host must never
             // receive an arbitrary AST object as a child of a CST node.
-            nd = host(type, kids, fieldMap, span, cap.rawChildren, cap.triviaLog, (flags & 8) !== 0 ? st : ctx.state !== undefined ? Object.assign({}, ctx.state as Record<string, unknown>) : undefined, tags)
+            nd = host(type, kids, fieldMap, span, cap.rawChildren, cap.triviaLog, ctx.state, tags)
           } else {
             const build = fns[buildIdx] as (
               children: readonly unknown[], fields: FieldMap | undefined, span: { start: number; end: number },
@@ -1573,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
@@ -1596,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
@@ -1606,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
@@ -1616,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

package/src/table/factor-choice.ts

@@ -0,0 +1,173 @@
+/**
+ * SHARED ENDS, FACTORED — a choice whose arms differ in one term.
+ *
+ * `choice(leaf(noTrivia(sequence(gap, '*', gap))), leaf(noTrivia(sequence(gap, '+', gap))))`
+ * scans `gap` once per arm, and on a value with no operator (`red red`) both
+ * arms scan it and then fail. Every arm is the same wrappers over a sequence of
+ * the same terms except one, so the choice is that one term:
+ *
+ *   leaf(noTrivia(sequence(gap, choice('*', '+'), gap)))
+ *
+ * The gap is scanned once, and the inner choice dispatches on the character
+ * after it.
+ *
+ * WHY IT IS THE SAME PARSE. Each arm is tried at the same position with the same
+ * context, so its terms before the differing one match the same text with the
+ * same value in every arm: running them once is what each arm's retry did. The
+ * inner choice tries the differing terms in arm order, as the outer one tried
+ * the arms. The terms after it may differ only as `optional`/`many`, which
+ * cannot fail, so the arm that matched its differing term is the arm the outer
+ * choice took. The sequence's values, the wrappers' spans and the leaf or node a
+ * wrapper publishes are what that arm produced.
+ *
+ * A choice that fails rolls its last arm back and reports the position it started
+ * at, so the factored form is an `attempt`, which does both. An arm that may
+ * commit is left as written: a committed choice reports without rolling back.
+ *
+ * WHAT "THE SAME" MEANS. Two terms are the same when they are one combinator, or
+ * their definitions are, field for field, down to shared combinators. A reducer
+ * is the same function, or the same printed source: a table artifact carries a
+ * reducer AS its source, so two reducers printed alike are one function there.
+ */
+import type { Combinator, ParserDef } from '../types.ts'
+import { choice } from '../combinators/choice.ts'
+import { sequence } from '../combinators/sequence.ts'
+import { leaf, sourceLeaf } from '../combinators/token.ts'
+import { noTrivia, parser } from '../combinators/grammar.ts'
+import { attempt } from '../combinators/attempt.ts'
+import { mayCommitFailure } from '../analysis/commitment.ts'
+
+type ChoiceDef = Extract<ParserDef, { tag: 'choice' }>
+
+/** Own keys every combinator may carry beside its definition; all derived from it. */
+const DERIVED = new Set(['_tag', '_meta', '_def', '_parseScalar', '_stickyRegex', 'parse'])
+
+function isCombinator(v: unknown): v is Combinator<unknown> {
+  return typeof v === 'object' && v !== null && '_def' in v && '_meta' in v
+}
+
+function sameComb(a: Combinator<unknown>, b: Combinator<unknown>, depth: number): boolean {
+  if (a === b) return true
+  if (depth > 32 || a._tag !== b._tag) return false
+  for (const k of Object.keys(a)) if (!DERIVED.has(k)) return false
+  for (const k of Object.keys(b)) if (!DERIVED.has(k)) return false
+  return sameFields(a._def as Record<string, unknown>, b._def as Record<string, unknown>, depth, undefined)
+}
+
+function sameValue(u: unknown, v: unknown, depth: number): boolean {
+  if (u === v) return true
+  if (isCombinator(u) && isCombinator(v)) return sameComb(u, v, depth + 1)
+  if (Array.isArray(u) && Array.isArray(v)) return u.length === v.length && u.every((x, i) => sameValue(x, v[i], depth))
+  if (typeof u === 'object' && u !== null && typeof v === 'object' && v !== null
+    && Object.getPrototypeOf(u) === Object.prototype && Object.getPrototypeOf(v) === Object.prototype) {
+    return sameFields(u as Record<string, unknown>, v as Record<string, unknown>, depth, undefined)
+  }
+  return false
+}
+
+/** Every field of `x` and `y` the same, `skip` aside. A reducer matches its twin by printed source. */
+function sameFields(x: Record<string, unknown>, y: Record<string, unknown>, depth: number, skip: string | undefined): boolean {
+  const kx = Object.keys(x).filter(k => k !== skip && x[k] !== undefined)
+  const ky = Object.keys(y).filter(k => k !== skip && y[k] !== undefined)
+  if (kx.length !== ky.length) return false
+  for (const k of kx) {
+    if (!(k in y)) return false
+    const u = x[k]
+    const v = y[k]
+    if (k === 'fn' && typeof u === 'function' && typeof v === 'function' && u !== v) {
+      if (typeof x.fnSrc !== 'string' || x.fnSrc === '' || x.fnSrc !== y.fnSrc) return false
+      continue
+    }
+    if (!sameValue(u, v, depth)) return false
+  }
+  return true
+}
+
+/** A wrapper the factoring can rebuild around a new body: a leaf, or a trivia scope. */
+function rewrap(w: Combinator<unknown>, body: Combinator<unknown>): Combinator<unknown> | undefined {
+  const d = w._def
+  let out: Combinator<unknown>
+  if (d.tag === 'leaf') {
+    out = d.cstValue === 'source' ? sourceLeaf(body, d.fn) : leaf(body, d.fn)
+    if (d.fnSrc !== undefined) (out._def as { fnSrc?: string }).fnSrc = d.fnSrc
+  } else if (d.tag === 'grammar') {
+    out = d.clearTrivia === true ? noTrivia(body) : parser({ trivia: d.triviaParser ?? null }, body)
+  } else return undefined
+  // The rebuilt wrapper must be the original in everything but its body.
+  return sameFields(d as Record<string, unknown>, out._def as Record<string, unknown>, 0, 'parser') ? out : undefined
+}
+
+function unusedOf(seq: Combinator<unknown>): boolean {
+  return seq._def.tag === 'sequence' && seq._def.valueUnused === true
+}
+
+function never(c: Combinator<unknown>): boolean {
+  const t = c._def.tag
+  return t === 'optional' || t === 'many'
+}
+
+/**
+ * The factored form of `d`'s choice, or `undefined` when its arms are not one
+ * shape that differs in one term.
+ */
+export function factorSharedEnds(d: ChoiceDef): Combinator<unknown> | undefined {
+  const arms = d.parsers
+  if (arms.length < 2) return undefined
+  if (d.strategy.tag !== 'firstMatch' && d.strategy.tag !== 'sharedPrefix') return undefined
+  if (d.gates.some(g => g !== null) || d.autoNot.some(a => a !== null)) return undefined
+  // Each arm: its wrappers, outermost first, and the sequence they end in.
+  const shapes: { wrappers: Combinator<unknown>[]; terms: Combinator<unknown>[]; seq: Combinator<unknown> }[] = []
+  for (const arm of arms) {
+    const wrappers: Combinator<unknown>[] = []
+    let c = arm
+    while ((c._def.tag === 'leaf' || c._def.tag === 'grammar') && wrappers.length < 4) {
+      wrappers.push(c)
+      c = c._def.parser
+    }
+    if (c._def.tag !== 'sequence' || c._def.parsers.length < 2) return undefined
+    shapes.push({ wrappers, terms: c._def.parsers, seq: c })
+  }
+  const first = shapes[0]!
+  const n = first.terms.length
+  for (const s of shapes) {
+    if (s.wrappers.length !== first.wrappers.length || s.terms.length !== n) return undefined
+    if (unusedOf(s.seq) !== unusedOf(first.seq)) return undefined
+    for (let j = 0; j < s.wrappers.length; j++) {
+      const a = first.wrappers[j]!._def as Record<string, unknown>
+      const b = s.wrappers[j]!._def as Record<string, unknown>
+      if (a.tag !== b.tag || !sameFields(a, b, 0, 'parser')) return undefined
+    }
+  }
+  // Exactly one term position differs, and nothing after it can fail.
+  let at = -1
+  for (let i = 0; i < n; i++) {
+    if (shapes.every(s => sameComb(s.terms[i]!, first.terms[i]!, 0))) continue
+    if (at >= 0) return undefined
+    at = i
+  }
+  if (at < 0) return undefined
+  for (let i = at + 1; i < n; i++) if (!never(first.terms[i]!)) return undefined
+  // A committed failure leaves a choice without rolling its arm back. Asked last:
+  // it walks everything the arms reach.
+  if (arms.some(a => mayCommitFailure(a))) return undefined
+  const middle = choice(...(shapes.map(s => s.terms[at]!) as [Combinator<unknown>, ...Combinator<unknown>[]]))
+  // The inner choice must keep arm order: a strategy that reorders (longest
+  // literal first) or classifies would pick a different arm. Nor may it add an
+  // automatic lookahead the arms as written do not have: `'start'` before
+  // `'started'` gets a `not('ed')` as one choice, which rejects the `!start` the
+  // written arms take on `!started`.
+  if (middle._def.tag === 'choice' && middle._def.autoNot.some(a => a !== null)) return undefined
+  const st = middle._def.tag === 'choice' ? middle._def.strategy : undefined
+  if (st === undefined || (st.tag !== 'firstMatch' && st.tag !== 'sharedPrefix'
+    && !(st.tag === 'literalsLongestFirst' && st.sortedIndices.every((x, i) => x === i)))) return undefined
+  let out: Combinator<unknown> | undefined = sequence(
+    ...([...first.terms.slice(0, at), middle, ...first.terms.slice(at + 1)] as [Combinator<unknown>, ...Combinator<unknown>[]]),
+  )
+  if (unusedOf(first.seq)) {
+    (out._def as { valueUnused?: boolean }).valueUnused = true
+  }
+  for (let j = first.wrappers.length - 1; j >= 0 && out !== undefined; j--) out = rewrap(first.wrappers[j]!, out)
+  // A choice that fails is rolled back and reports where it started; so does an
+  // `attempt`. The sequence alone would report where its inner choice failed.
+  return out === undefined ? undefined : attempt(out)
+}