parseman 0.61.5 → 0.61.7

package/dist/table/select-hot.d.ts

@@ -8,6 +8,15 @@ export declare function selectHotSites(code: readonly number[], entries: readonl
 /** Measured calls per site (`countSiteVisits` over a corpus). Replaces the
  * static estimate when given. */
 profile?: ArrayLike<number>): Set<number>;
+/**
+ * The sites the function for `ip` calls, as `emit-assembly.ts` lowers it. An `OP_CONT`
+ * with a body is a late frame, lowered with its wrapper in one function, calling its
+ * corner and its tail. With no body, the emitter can't decide there and it's an alias
+ * to its wrapper, as `OP_SEED` is to its corner. A gap gate has no body either, so its
+ * item counts as the repeat's own child, and adding the row moves no other site's
+ * estimate (`gap-gate.ts`).
+ */
+export declare function edgesAsLowered(code: readonly number[], siteBytes: ReadonlyMap<number, number>, ip: number, out: number[]): void;
 /**
  * The largest prefix of the ranking whose real source fits `ceiling`. `siteBytes`
  * leaves out what sites add around their bodies, so the estimate can overshoot:

package/dist/table/select-hot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select-hot.d.ts","sourceRoot":"","sources":["../../src/table/select-hot.ts"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,MAAM;AACd;iCACiC;AACjC,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B,GAAG,CAAC,MAAM,CAAC,CAgBb;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;AACtC,2DAA2D;AAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,EACnD,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQ7E"}
+{"version":3,"file":"select-hot.d.ts","sourceRoot":"","sources":["../../src/table/select-hot.ts"],"names":[],"mappings":"AAqCA;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EACtC,MAAM,EAAE,MAAM;AACd;iCACiC;AACjC,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B,GAAG,CAAC,MAAM,CAAC,CAUb;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAe/H;AAqDD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC;AACtC,2DAA2D;AAC3D,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,EACnD,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAC1B;IAAE,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAQ7E"}

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.61.5";
+export declare const PARSEMAN_VERSION = "0.61.7";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.61.5",
+  "version": "0.61.7",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/combinators/expect.ts

@@ -1,7 +1,7 @@
 import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseError } from '../types.ts'
 import { captureError } from '../recovery/scan.ts'
 import { annotateSpanFromLineContext } from '../line-index.ts'
-import { matchesEmpty, isZeroWidthAssertion } from './first-set.ts'
+import { any, matchesEmpty, isZeroWidthAssertion } from './first-set.ts'
 
 export type { ParseError }
 export { assertionFailureExpected, directTerminalFailureExpected } from './expected.ts'
@@ -133,7 +133,8 @@ function derive(c: Combinator<unknown>, seen: Set<Combinator<unknown>>): string[
 export function expect<T>(combinator: Combinator<T>, label?: string): Combinator<T | ParseError> {
   const expected = label !== undefined ? [label] : deriveExpected(combinator)
   const meta: ParserMeta = {
-    firstSet: combinator._meta.firstSet,
+    // It runs on any character: on one its child can't start, it reports the error.
+    firstSet: any(),
     canMatchNewline: combinator._meta.canMatchNewline,
     isTrivia: false,
   }

package/src/combinators/first-set.ts

@@ -202,7 +202,8 @@ function matchesEmptyBody(
     case 'many':
     case 'optional':
     case 'not':
-    case 'peek':     return true          // zero repetitions / absent / lookahead
+    case 'peek':
+    case 'expect':   return true          // zero repetitions / absent / lookahead / recovered
     // Default `sepBy` is `(item (sep item)*)?` — it MATCHES THE EMPTY STRING.
     // Any `min >= 1` requires that many ITEMS, so it is nullable only when the
     // item is. (Keying this off `min === 1` reported every `{ min: 2 }` list as
@@ -220,7 +221,6 @@ function matchesEmptyBody(
     case 'trivia':
     case 'token':
     case 'leaf':
-    case 'expect':
     case 'withCtx':
     case 'node':
     case 'grammar':
@@ -382,6 +382,8 @@ export function sequenceFirstSet(parsers: readonly Combinator<unknown>[]): First
  * repeat item's, a gap's and a node's gate read a pad through its non-empty
  * matches.
  *
+ * `follow: true` asks where a resync sentinel stops, which reads through `expect`.
+ *
  * `activeTrivia` is the live trivia, `null` for a scope known to have none (where
  * a reference installs its rule's trivia, `triviaThroughRef`), and `undefined`
  * where it is not known.
@@ -396,6 +398,7 @@ export function firstSetOf(
   resolve?: RefResolver,
   activeTrivia?: Combinator<unknown> | null,
   consuming = true,
+  follow = false,
 ): FirstSet {
   // `seen` is the current recursion path, not a global visited set. A completed
   // shared child must be analysed again for a sibling; only a back-edge on this
@@ -403,7 +406,7 @@ export function firstSetOf(
   if (seen.has(p)) return any()               // cycle → any (safe over-approximation)
   seen.add(p)
   try {
-    return firstSetBody(p, seen, resolve, activeTrivia, consuming)
+    return firstSetBody(p, seen, resolve, activeTrivia, consuming, follow)
   } finally {
     seen.delete(p)
   }
@@ -415,8 +418,9 @@ function firstSetBody(
   resolve: RefResolver | undefined,
   activeTrivia: Combinator<unknown> | null | undefined,
   consuming: boolean,
+  follow: boolean,
 ): FirstSet {
-  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen, resolve, activeTrivia, consuming)
+  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen, resolve, activeTrivia, consuming, follow)
   const empties = (c: Combinator<unknown>): boolean => matchesEmpty(c, new Set(), resolve)
   const d = p._def as ParserDef
   switch (d.tag) {
@@ -437,7 +441,7 @@ function firstSetBody(
       // install; the interpreter's own callers (`sequence.ts` follow sentinels)
       // read a reference as 0.58.0 did (#223).
       const through = activeTrivia === null && resolve !== undefined
-      return firstSetOf(target, seen, resolve, through ? triviaThroughRef(p, target, null) : activeTrivia, consuming)
+      return firstSetOf(target, seen, resolve, through ? triviaThroughRef(p, target, null) : activeTrivia, consuming, follow)
     }
     case 'choice': {
       let out: FirstSet = empty()
@@ -457,6 +461,9 @@ function firstSetBody(
       // original cursor.
       return sequenceSet(d.parsers, fs, empties, activeTrivia, consuming)
     }
+    // Runs on any character: on one its child can't start, it reports the error. A
+    // resync sentinel still stops where the child could start.
+    case 'expect':    return follow ? fs(d.parser) : any()
     case 'peek': {
       // Deep-resolve the body: a `ref()` reads `any()` at CONSTRUCTION, so the
       // shallow `_meta.firstSet` baked into the assertion would lose the gate.
@@ -472,19 +479,19 @@ function firstSetBody(
     case 'leaf':
     case 'node':
     case 'sepBy':
-    case 'expect':
     // A transaction accepts exactly what its inner accepts. Its own `_meta` is
     // the inner's construction-time set, which reads `any` when the inner opens
     // with a rule reference — resolve through it like any other wrapper.
     case 'attempt':   return fs(d.parser)
     // A token runs its body with trivia cleared (`token.ts`).
-    case 'token':     return firstSetOf(d.parser, seen, resolve, activeTrivia === undefined ? undefined : null, consuming)
+    case 'token':     return firstSetOf(d.parser, seen, resolve, activeTrivia === undefined ? undefined : null, consuming, follow)
     case 'grammar':   return firstSetOf(
       d.parser,
       seen,
       resolve,
       d.clearTrivia ? null : (d.triviaParser ?? activeTrivia),
       consuming,
+      follow,
     )
     // A run starts with its first line's prefix; a nullable prefix starts with anything.
     case 'lines': {

package/src/combinators/sequence.ts

@@ -108,7 +108,7 @@ export function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[
       if (tolerant) {
         followSentinels ??= parsers.map((_, i) => firstSetSentinel(
           parsers.slice(i + 1).reduce<ReturnType<typeof firstSetOf>>(
-            (set, parser) => union(set, firstSetOf(parser, new Set(), undefined, undefined, false)), { kind: 'empty' },
+            (set, parser) => union(set, firstSetOf(parser, new Set(), undefined, undefined, false, true)), { kind: 'empty' },
           ),
         ))
       }

package/src/plugin/entry-supercompiler.ts

@@ -65,6 +65,8 @@ type Call = {
 type Edit = { readonly start: number; readonly end: number; readonly text: string }
 
 const PIECE = /^_pf(\d+)$/
+const MERGEABLE = /^_(?:pf|sk)\d+$/
+const TEMP = /^_t\d+_/
 const WRAP = 'function __parseman_supercompile__(){\n'
 const SUFFIX = '\n}'
 
@@ -225,6 +227,113 @@ export function supercompileEntryAssembly(
   return supercompileEmittedAssembly(prog, cfg, extraIps, emitted)
 }
 
+/** A name in the source: a site, or a temporary (`tmp` in `emit-assembly.ts`). */
+type NameUse = { readonly start: number; readonly end: number; readonly name: string }
+
+/** The uses of site and temporary names under `root`, and the names bound there. */
+function namesUnder(root: Ast, uses: NameUse[], bound: Set<string>): boolean {
+  let plain = true
+  const bind = (id: Ast | undefined): void => {
+    const name = nameOf(id)
+    if (name !== undefined) bound.add(name)
+  }
+  const walk = (node: Ast, parent: Ast | undefined): void => {
+    if (node.type === 'VariableDeclarator') bind(ast(node.id))
+    else if (node.type === 'LabeledStatement') bind(ast(node.label))
+    else if (isFunction(node)) {
+      if (node !== root) bind(ast(node.id))
+      nodes(node.params).forEach(bind)
+    }
+    const name = nameOf(node)
+    if (name !== undefined && (MERGEABLE.test(name) || TEMP.test(name))) {
+      const isKey = parent?.type === 'Property' && parent.key === node && parent.computed !== true
+      const isProperty = parent?.type === 'MemberExpression' && parent.property === node && parent.computed !== true
+      if (parent?.type === 'Property' && parent.shorthand === true) plain = false
+      if (!isKey && !isProperty) uses.push({ ...range(node), name })
+    }
+    for (const child of children(node)) walk(child, node)
+  }
+  walk(root, undefined)
+  return plain
+}
+
+/**
+ * Functions that read the same are one function: `optional(x)` written in 25 places
+ * is 25 rows and one body, and a trivia skip can be pooled under two labels that
+ * lower alike. This runs after the join, so a site with one caller has
+ * already gone into it, the selection is untouched and every call a parse makes is
+ * still made. Each pass can make the callers of a merged function read alike, so it
+ * repeats until nothing merges.
+ *
+ * Only identifiers are compared or renamed: a grammar's own text reaches this source
+ * as strings and regexes, and they count as written. A temporary is local by the
+ * emitter's contract and is numbered per assembly, so one this function binds is
+ * compared in order of use. A site name that's also bound somewhere, or abbreviated
+ * in `{_pf1}`, can't be renamed by name, so that source stays as it is.
+ */
+export function mergeSameBodies(source: string): string {
+  const parsed = parseSync('parseman-merge-same-bodies.js', WRAP + source + SUFFIX)
+  if (parsed.errors.length > 0) return source
+  const statements = nodes(ast(nodes((parsed.program as unknown as Ast).body)[0]?.body)?.body)
+  type Body = NameUse & { readonly uses: readonly NameUse[]; readonly local: ReadonlySet<string> }
+  const bodies: Body[] = []
+  const others: NameUse[] = []
+  const declared = new Set<string>()
+  for (const statement of statements) {
+    const name = statement.type === 'FunctionDeclaration' ? nameOf(ast(statement.id)) : undefined
+    const uses: NameUse[] = []
+    const bound = new Set<string>()
+    if (!namesUnder(statement, uses, bound)) return source
+    for (const local of bound) declared.add(local)
+    if (name === undefined || !MERGEABLE.test(name)) others.push(...uses)
+    else bodies.push({ ...range(statement), name, uses: uses.sort((a, b) => a.start - b.start), local: bound })
+  }
+  for (const local of declared) if (MERGEABLE.test(local)) return source
+
+  const merged = new Map<string, string>()
+  const current = (name: string): string => {
+    let at = name
+    for (let next = merged.get(at); next !== undefined; next = merged.get(at)) at = next
+    return at
+  }
+  let live = bodies
+  for (let more = true; more;) {
+    more = false
+    const first = new Map<string, string>()
+    live = live.filter(body => {
+      const temps = new Map<string, number>()
+      const edits = body.uses.map((use): Edit => {
+        if (MERGEABLE.test(use.name)) {
+          const site = current(use.name)
+          return { ...use, text: site === body.name ? '#self' : site }
+        }
+        if (!body.local.has(use.name)) return { ...use, text: use.name }
+        const seen = temps.get(use.name) ?? temps.size
+        temps.set(use.name, seen)
+        return { ...use, text: `#t${seen}` }
+      })
+      const key = render(source, body.start, body.end, edits)
+      const kept = first.get(key)
+      if (kept === undefined) { first.set(key, body.name); return true }
+      merged.set(body.name, kept)
+      more = true
+      return false
+    })
+  }
+  if (merged.size === 0) return source
+
+  const edits: Edit[] = []
+  const rename = (use: NameUse): void => {
+    if (MERGEABLE.test(use.name) && merged.has(use.name)) edits.push({ ...use, text: current(use.name) })
+  }
+  others.forEach(rename)
+  for (const body of bodies) {
+    if (merged.has(body.name)) edits.push({ start: body.start, end: body.end, text: '' })
+    else body.uses.forEach(rename)
+  }
+  return render(source, 0, source.length, edits)
+}
+
 /**
  * Plugin-only final splice for an ordinary macro replacement. The table
  * compiler emits its canonical callback-free public artifact first; this pass
@@ -274,7 +383,7 @@ export function supercompileRuleMapReplacement(
   const start = body.start - prefix.length + 1
   const end = body.end - prefix.length - 1
   if (replacement.slice(start, end) !== FACTORY_ARITY_GUARD + canonical.source + '\n') return replacement
-  const transformed = replacement.slice(0, start) + FACTORY_ARITY_GUARD + candidate.source + '\n' + replacement.slice(end)
+  const transformed = replacement.slice(0, start) + FACTORY_ARITY_GUARD + mergeSameBodies(candidate.source) + '\n' + replacement.slice(end)
   const checked = parseSync('parseman-entry-supercompile-replacement-result.js', prefix + transformed)
   return checked.errors.length === 0 ? transformed : replacement
 }

package/src/table/assemble.ts

@@ -2844,8 +2844,46 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
         }
         if (hasAdj) {
           const first = linkFirst()
+          // What a held gap needs undone if the next term recovers at zero width.
+          // Written after the lookahead returns and read before the next term runs,
+          // so nothing can re-enter this sequence in between.
+          let heldFrom = 0, heldTl = 0, heldScanTl = 0, heldLog = 0, heldScanLog = 0, heldRoot = 0, heldScanRoot = 0
           const runnerAt = (i: number): TermRunner => {
             const kidIp = code[base + i]!
+            if (i > 1 && holdsGap(code, k, base, n, i - 1, NULLABLE) && rowNullable(code, k, kidIp, NULLABLE)) {
+              const kid = link(kidIp)
+              return (input, cur, ctx) => {
+                const from = heldFrom, tl = heldTl, scanTl = heldScanTl, log = heldLog
+                const scanLog = heldScanLog, root = heldRoot, scanRoot = heldScanRoot
+                const next = step(kid, input, cur, ctx)
+                if (next !== cur || from === cur) return next
+                rollbackScannedTriviaAt(ctx, tl, scanTl, log, scanLog, root, scanRoot)
+                return from
+              }
+            }
+            if (holdsGap(code, k, base, n, i, NULLABLE) && rowNullable(code, k, code[base + i + 1]!, NULLABLE)) {
+              const kid = link(kidIp)
+              return (input, cur, ctx) => {
+                if (ctx.trivia === undefined) {
+                  const v = kid(input, cur, ctx)
+                  if (v === FAIL) return -1
+                  TERMV = v
+                  heldFrom = cur
+                  return EC.e
+                }
+                const tl = cstTlLen(ctx), log = ctx._triviaLog?.length ?? 0, root = ctx._rootTriviaLog?.length ?? 0
+                const scanEnd = skipTrivia(input, cur, ctx)
+                const scanTl = cstTlLen(ctx), scanLog = ctx._triviaLog?.length ?? 0, scanRoot = ctx._rootTriviaLog?.length ?? 0
+                const v = kid(input, scanEnd, ctx)
+                if (v === FAIL) return -1
+                TERMV = v
+                heldFrom = cur
+                heldTl = tl; heldScanTl = scanTl
+                heldLog = log; heldScanLog = scanLog
+                heldRoot = root; heldScanRoot = scanRoot
+                return scanEnd
+              }
+            }
             if (holdsGap(code, k, base, n, i, NULLABLE)) {
               const kid = link(kidIp)
               return (input, cur, ctx) => {

package/src/table/emit-assembly.ts

@@ -467,16 +467,40 @@ ${scanned}
 }`
 }
 
+const TRIVIA_LOG_LENGTH = 'ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)'
+
 /**
  * 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.
+ * term, which cannot match empty unless it `recovers`. Then the marks stay in
+ * scope for `emitHeldGapUndo`, which follows the next term.
  */
-function emitHoldTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string): string {
+function emitHoldTerm(callee: string, dst: string, t: string, l: SiteLabel, skip: string, recovers: boolean): string {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
 cur=EC.e`
+  if (recovers) {
+    const marked = `let ${t}c=cur,${t}s=cur,${t}tl=0,${t}stl=0,${t}lg=0,${t}slg=0,${t}rt=0,${t}srt=0`
+    if (l.tri === TRI_NONE) return `${marked}\n${fast}`
+    const held = `${t}tl=${TRIVIA_LOG_LENGTH}
+${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+${t}s=${skip}(input,cur,ctx)
+${t}stl=${TRIVIA_LOG_LENGTH}
+${t}slg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${t}srt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
+const ${t}v=${callee}(input,${t}s,ctx)
+if(${t}v===FAIL)return FAIL
+${dst}=${t}v
+cur=${t}s`
+    return l.tri !== TRI_UNKNOWN ? `${marked}\n${held}` : `${marked}
+if(ctx.trivia===undefined){
+${fast}
+}else{
+${held}
+}`
+  }
   if (l.tri === TRI_NONE) return fast
   const held = `const ${t}s=${skip}(input,cur,ctx)
 const ${t}v=${callee}(input,${t}s,ctx)
@@ -491,6 +515,11 @@ ${held}
 }`
 }
 
+/** The next term recovered at zero width, so the gap held for it was never consumed. */
+function emitHeldGapUndo(t: string): string {
+  return `if(cur===${t}s&&${t}s!==${t}c){rollbackScannedTriviaAt(ctx,${t}tl,${t}stl,${t}lg,${t}slg,${t}rt,${t}srt);cur=${t}c}`
+}
+
 /**
  * The repetition's LEAD-TRIVIA skip, as a BLOCK.
  *
@@ -2019,6 +2048,7 @@ return v
         }
         parts.push('let cur=EC.e')
         const names: string[] = ['v0']
+        let heldUndo: string | undefined
         for (let i = 1; i < n; i++) {
           const vn = `v${i}`
           parts.push(`let ${vn}`)
@@ -2038,9 +2068,16 @@ 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(holdsGap(code, k, base, n, i, nullable)
-              ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L))
-              : emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : undefined))
+            if (holdsGap(code, k, base, n, i, nullable)) {
+              const t = tmp()
+              const recovers = rowNullable(code, k, code[base + i + 1]!, nullable)
+              parts.push(emitHoldTerm(callee, vn, t, L, skipFor(L), recovers))
+              heldUndo = recovers ? t : undefined
+            } else {
+              parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L), L.tri >= 0 ? triviaMiss(L.tri) : undefined))
+              if (heldUndo !== undefined) parts.push(emitHeldGapUndo(heldUndo))
+              heldUndo = undefined
+            }
           }
           names.push(vn)
         }

package/src/table/encode.ts

@@ -751,7 +751,7 @@ class Encoder {
     for (let j = i + 1; j < parsers.length; j++) {
       // As the interpreter's `followSentinels` derive them (`sequence.ts`): with no
       // trivia, whatever scope the sequence runs in.
-      fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr, undefined, false))
+      fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr, undefined, false, true))
     }
     return this.charClass(fs)
   }

package/src/table/hold-gap.ts

@@ -13,6 +13,10 @@
  *
  * Not before an adjacency assertion or a leading-trivia field, which read the
  * cursor from before the gap.
+ *
+ * A next term that can match empty only by recovering (`expect`) holds the gap
+ * too, so valid text still scans it once. If it does recover, the gap is
+ * unrecorded and the cursor goes back, where only invalid text pays for it.
  */
 import {
   OP_ADJ, OP_ATTEMPT, OP_CHOICE, OP_COV, OP_EXPECT, OP_FIELD, OP_GATE, OP_LABEL, OP_LEAF, OP_LIT, OP_LIT_CI,
@@ -24,16 +28,21 @@ import { leadingTriviaFieldAt } from './field-spec.ts'
 import { regexCanMatchEmpty } from '../regex/first-set.ts'
 
 const WRAPPERS = new Set([OP_NODE, OP_XFORM, OP_LEAF, OP_SOURCE_LEAF, OP_TOKEN, OP_SCOPE, OP_SCOPE_CAP,
-  OP_SCOPE_PLAIN, OP_FIELD, OP_LABEL, OP_EXPECT, OP_WITHCTX, OP_RULE, OP_ATTEMPT, OP_COV, OP_GAPGATE])
+  OP_SCOPE_PLAIN, OP_FIELD, OP_LABEL, OP_WITHCTX, OP_RULE, OP_ATTEMPT, OP_COV, OP_GAPGATE])
 
 /**
  * Can the row at `ip` match empty? `true` wherever it cannot tell. A first-set
  * gate row wraps only a child that cannot (`encode.ts` gates nothing nullable).
+ * An `expect` recovers at zero width whatever its child needs; with `recovers`
+ * false, this asks what the row can match empty without recovering.
  */
-export function rowNullable(code: ArrayLike<number>, k: readonly unknown[], ip: number, memo: Map<number, boolean>): boolean {
-  const hit = memo.get(ip)
+export function rowNullable(
+  code: ArrayLike<number>, k: readonly unknown[], ip: number, memo: Map<number, boolean>, recovers = true,
+): boolean {
+  const key = recovers ? ip : ~ip
+  const hit = memo.get(key)
   if (hit !== undefined) return hit
-  memo.set(ip, true) // a cycle is answered conservatively
+  memo.set(key, true) // a cycle is answered conservatively
   const op = code[ip]!
   const kids: number[] = []
   let out = true
@@ -42,20 +51,20 @@ export function rowNullable(code: ArrayLike<number>, k: readonly unknown[], ip:
   else if (op === OP_RX) { const re = k[code[ip + 1]!]; out = !(re instanceof RegExp) || regexCanMatchEmpty(re.source) }
   else if (op === OP_SEQ || op === OP_SEQV || op === OP_SEQX) {
     childSlots(code, ip, kids)
-    out = kids.every(c => rowNullable(code, k, c, memo))
+    out = kids.every(c => rowNullable(code, k, c, memo, recovers))
   } else if (op === OP_CHOICE) {
     childSlots(code, ip, kids)
-    out = kids.length === 0 || kids.some(c => rowNullable(code, k, c, memo))
+    out = kids.length === 0 || kids.some(c => rowNullable(code, k, c, memo, recovers))
   } else if (op === OP_REP || op === OP_REPV) {
-    out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1]!, memo)
+    out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1]!, memo, recovers)
   } else if (op === OP_SEED) {
-    out = rowNullable(code, k, code[ip + 1]!, memo)
+    out = rowNullable(code, k, code[ip + 1]!, memo, recovers)
   } else if (op === OP_CONT) {
-    out = rowNullable(code, k, code[ip + 1]!, memo) && rowNullable(code, k, code[ip + 3]!, memo)
-  } else if (WRAPPERS.has(op)) {
-    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0]!, memo)
+    out = rowNullable(code, k, code[ip + 1]!, memo, recovers) && rowNullable(code, k, code[ip + 3]!, memo, recovers)
+  } else if (WRAPPERS.has(op) || (op === OP_EXPECT && !recovers)) {
+    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0]!, memo, recovers)
   }
-  memo.set(ip, out)
+  memo.set(key, out)
   return out
 }
 
@@ -68,5 +77,5 @@ export function holdsGap(
   if (code[term] !== OP_NOT && code[term] !== OP_PEEK) return false
   const next = code[base + i + 1]!
   if (code[next] === OP_ADJ || leadingTriviaFieldAt(code, k, next)) return false
-  return !rowNullable(code, k, next, memo)
+  return !rowNullable(code, k, next, memo, false)
 }