parseman 0.50.6 → 0.51.0

package/src/combinators/scanTo.ts

@@ -32,6 +32,28 @@ export type ScanToOptions = {
    * everything consumed so far. Default false (fail at EOF).
    */
   orEOF?: boolean
+  /**
+   * A delimiter owned by the surrounding grammar that may terminate an
+   * unfinished scan. Unlike putting that delimiter in `sentinel`, `scanTo`
+   * keeps looking for a real sentinel so the same delimiter may appear in a
+   * complete payload.
+   *
+   * This mode is intended for paired sentinels such as quotes. Once a recovery
+   * point has been seen, later sentinels are counted as alternating close/open
+   * delimiters. At the next outer recovery point (or EOF), an odd count accepts
+   * the first sentinel; an even count returns the first recovery point. This
+   * preserves complete payloads such as `` `let x = 1; x` `` without pairing an
+   * unfinished payload with a later construct's opening delimiter.
+   */
+  recoverAt?: Combinator<unknown>
+  /**
+   * An unconditional recovery boundary. The scan resolves at this position
+   * using the same paired-sentinel decision as EOF. A hard stop is checked at
+   * the current scan position before opaque skippers. A skipper that began at an
+   * earlier position remains opaque throughout its matched span. Use this for
+   * boundaries such as a line end after an escape character.
+   */
+  stopAt?: Combinator<unknown>
   /**
    * `balanced()` only. Make an unmatched close a genuine FAILURE instead of a
    * recovered one.
@@ -97,7 +119,7 @@ export function resolveScanSkip(
  */
 export function scanTo(
   sentinel: Combinator<unknown>,
-  { skip, raw = false, orEOF = false }: ScanToOptions = {},
+  { skip, raw = false, orEOF = false, recoverAt, stopAt }: ScanToOptions = {},
 ): Combinator<string> {
   const meta: ParserMeta = {
     firstSet: any(),
@@ -109,7 +131,11 @@ export function scanTo(
   return {
     _tag: 'scanTo',
     _meta: meta,
-    _def: { tag: 'scanTo', sentinel, skip: explicitSkip, raw, orEOF },
+    _def: {
+      tag: 'scanTo', sentinel, skip: explicitSkip, raw, orEOF,
+      ...(recoverAt === undefined ? {} : { recoverAt }),
+      ...(stopAt === undefined ? {} : { stopAt }),
+    },
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<string> {
       let cur = pos
       // Fold grammar-level ambient trivia + scanSkip into the effective skippers.
@@ -133,35 +159,163 @@ export function scanTo(
         }
       }
 
+      // Keep ordinary scanTo on its established hot path. Recovery adds probes,
+      // parity, and diagnostic checkpoints inside the byte loop; selecting that
+      // machinery at construction scope would tax every CSS prelude scan even
+      // though almost all scanTo sites use neither recovery option.
+      if (recoverAt === undefined && stopAt === undefined) {
+        while (cur < input.length) {
+          const s = sentinel.parse(input, cur, probeCtx)
+          if (s.ok) {
+            if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur)
+            emit(cur)
+            return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }
+          }
+
+          let advanced = false
+          for (const skipper of skip) {
+            const r = skipper.parse(input, cur, probeCtx)
+            if (r.ok && r.span.end > cur) {
+              cur = r.span.end
+              advanced = true
+              break
+            }
+          }
+          if (!advanced) cur++
+        }
+
+        if (orEOF) {
+          if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur)
+          emit(cur)
+          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }
+        }
+        const sentDef = sentinel._def
+        const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']
+        return { ok: false, expected, span: { start: pos, end: cur } }
+      }
+
+      let recovery = -1
+      let firstSentinel = -1
+      let sentinelCount = 0
+      let recoveryErrorCount = -1
+      let sentinelErrorCount = -1
+
+      const succeed = (end: number): ParseResult<string> => {
+        if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end)
+        emit(end)
+        return { ok: true, value: input.slice(pos, end), span: { start: pos, end } }
+      }
+
+      const recoveredEnd = () => {
+        const acceptSentinel = firstSentinel >= 0 && (sentinelCount & 1) === 1
+        const errors = ctx._errors
+        if (errors !== undefined) {
+          const keep = acceptSentinel ? sentinelErrorCount : recoveryErrorCount
+          if (keep >= 0 && errors.length > keep) errors.length = keep
+        }
+        return acceptSentinel ? firstSentinel : recovery
+      }
+
       while (cur < input.length) {
         // Check sentinel — if it matches here, stop and return consumed text.
+        const sentinelProbeErrorCount = ctx._errors?.length ?? -1
         const s = sentinel.parse(input, cur, probeCtx)
+        const sentinelProbeErrors = ctx._errors
+        if (sentinelProbeErrors !== undefined
+            && sentinelProbeErrorCount >= 0
+            && sentinelProbeErrors.length > sentinelProbeErrorCount) {
+          sentinelProbeErrors.length = sentinelProbeErrorCount
+        }
         if (s.ok) {
-          if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur)
-          emit(cur)
-          return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }
+          if (recovery < 0) return succeed(cur)
+          if (s.span.end <= cur) {
+            throw new TypeError('scanTo recovery requires a sentinel that consumes input')
+          }
+          if (firstSentinel < 0) {
+            firstSentinel = cur
+            sentinelErrorCount = sentinelProbeErrorCount
+          }
+          sentinelCount++
+          cur = s.span.end
+          continue
+        }
+
+        // A hard stop is stronger than opacity: when both begin here, the stop
+        // must win so a skipper cannot carry the scan across a boundary that the
+        // caller declared uncrossable. The sentinel still has first priority.
+        if (stopAt !== undefined) {
+          const errorCount = ctx._errors?.length ?? -1
+          const stop = stopAt.parse(input, cur, probeCtx)
+          const errors = ctx._errors
+          if (errors !== undefined && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount
+          }
+          if (stop.ok) {
+            if (recovery < 0) {
+              recovery = cur
+              recoveryErrorCount = errorCount
+            }
+            return succeed(recoveredEnd())
+          }
         }
 
         // Try each skipper in order; take first that advances.
         let advanced = false
         for (const skipper of skip) {
+          const errorCount = ctx._errors?.length ?? -1
           const r = skipper.parse(input, cur, probeCtx)
           if (r.ok && r.span.end > cur) {
             cur = r.span.end
             advanced = true
             break
           }
+          // A skipper is a speculative opaque-region probe. If it recognizes
+          // an opener but cannot finish (for example strict balanced('(', ')')
+          // at an outer recovery boundary), its committed diagnostic belongs
+          // only to that failed probe. Letting it escape makes an otherwise
+          // successful recovery look malformed to the enclosing tolerant list.
+          const errors = ctx._errors
+          if (errors !== undefined && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount
+          }
+        }
+
+        // Opaque units protect recovery boundaries just as they protect the
+        // sentinel. A `{` owned by balanced('{', '}') is payload, not an outer
+        // recovery point, even when recoverAt can also begin with `{`.
+        if (advanced) continue
+
+        if (recoverAt !== undefined) {
+          const errorCount = ctx._errors?.length ?? -1
+          const recover = recoverAt.parse(input, cur, probeCtx)
+          const errors = ctx._errors
+          if (errors !== undefined && errorCount >= 0 && errors.length > errorCount) {
+            errors.length = errorCount
+          }
+          if (recover.ok) {
+            if (recover.span.end <= cur) {
+              throw new TypeError('scanTo recoverAt must consume input')
+            }
+            if (recovery < 0) {
+              recovery = cur
+              recoveryErrorCount = errorCount
+            }
+            if (firstSentinel >= 0 && (sentinelCount & 1) === 1) {
+              return succeed(recoveredEnd())
+            }
+            cur = recover.span.end
+            continue
+          }
         }
 
         // Nothing matched — consume one character and continue.
-        if (!advanced) cur++
+        cur++
       }
 
       // Reached EOF without finding sentinel.
+      if (recovery >= 0) return succeed(recoveredEnd())
       if (orEOF) {
-        if (ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, cur)
-        emit(cur)
-        return { ok: true, value: input.slice(pos, cur), span: { start: pos, end: cur } }
+        return succeed(cur)
       }
       const sentDef = sentinel._def
       const expected = sentDef.tag === 'literal' ? [JSON.stringify(sentDef.value)] : ['sentinel']

package/src/compiler/fields.ts

@@ -25,7 +25,10 @@ export function parserHasOwnFields(p: Combinator<unknown>, seen: Set<Combinator<
     case 'dispatch': return parserHasOwnFields(d.selector, seen) || d.cases.some(x => parserHasOwnFields(x.parser, seen)) || (d.matchers ? d.matchers.some(entry => parserHasOwnFields(entry.parser, seen)) : false) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false)
     case 'sepBy': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen)
     case 'grammar': return parserHasOwnFields(d.parser, seen) || (d.triviaParser ? parserHasOwnFields(d.triviaParser, seen) : false)
-    case 'scanTo': return parserHasOwnFields(d.sentinel, seen) || d.skip.some(x => parserHasOwnFields(x, seen))
+    case 'scanTo': return parserHasOwnFields(d.sentinel, seen)
+      || d.skip.some(x => parserHasOwnFields(x, seen))
+      || (d.recoverAt !== undefined && parserHasOwnFields(d.recoverAt, seen))
+      || (d.stopAt !== undefined && parserHasOwnFields(d.stopAt, seen))
     case 'recover': return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen)
     case 'routed': return d.fallback ? parserHasOwnFields(d.fallback, seen) : false
     case 'many':
@@ -151,7 +154,10 @@ export function parserEnablesTriviaCapture(p: Combinator<unknown>, seen: Set<Com
     case 'choice': return d.parsers.some(x => parserEnablesTriviaCapture(x, seen))
     case 'dispatch': return parserEnablesTriviaCapture(d.selector, seen) || d.cases.some(x => parserEnablesTriviaCapture(x.parser, seen)) || (d.matchers ? d.matchers.some(entry => parserEnablesTriviaCapture(entry.parser, seen)) : false) || (d.otherwise ? parserEnablesTriviaCapture(d.otherwise, seen) : false)
     case 'sepBy': return parserEnablesTriviaCapture(d.parser, seen) || parserEnablesTriviaCapture(d.separator, seen)
-    case 'scanTo': return parserEnablesTriviaCapture(d.sentinel, seen) || d.skip.some(x => parserEnablesTriviaCapture(x, seen))
+    case 'scanTo': return parserEnablesTriviaCapture(d.sentinel, seen)
+      || d.skip.some(x => parserEnablesTriviaCapture(x, seen))
+      || (d.recoverAt !== undefined && parserEnablesTriviaCapture(d.recoverAt, seen))
+      || (d.stopAt !== undefined && parserEnablesTriviaCapture(d.stopAt, seen))
     case 'recover': return parserEnablesTriviaCapture(d.parser, seen) || parserEnablesTriviaCapture(d.sentinel, seen)
     case 'routed': return d.fallback ? parserEnablesTriviaCapture(d.fallback, seen) : false
     case 'many':

package/src/compiler/grammar-coverage-ids.ts

@@ -33,7 +33,12 @@ function children(def: ParserDef, winners?: Record<string, Combinator<unknown>>)
     case 'dispatch': return [def.selector, ...def.cases.map(entry => entry.parser), ...(def.matchers ? def.matchers.map(entry => entry.parser) : []), ...(def.otherwise ? [def.otherwise] : [])]
     case 'many': case 'oneOrMore': case 'optional': case 'attempt': case 'transform': case 'trivia': case 'token': case 'leaf': case 'label': case 'field': case 'grammar': case 'not': case 'peek': case 'node': case 'guard': case 'adjacency': case 'withCtx': case 'recover': case 'expect': return 'parser' in def ? [def.parser] : []
     case 'sepBy': return [def.parser, def.separator]
-    case 'scanTo': return [def.sentinel, ...def.skip]
+    case 'scanTo': return [
+      def.sentinel,
+      ...def.skip,
+      ...(def.recoverAt === undefined ? [] : [def.recoverAt]),
+      ...(def.stopAt === undefined ? [] : [def.stopAt]),
+    ]
     case 'lazy': {
       let resolved: Combinator<unknown>
       try { resolved = def.thunk() } catch (e) {

package/src/compiler/ir-serialize.ts

@@ -65,7 +65,12 @@ function childrenOf(def: ParserDef): Comb[] {
     case 'expect':    return [def.parser]
     case 'grammar':   return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser]
     case 'sepBy':     return [def.parser, def.separator]
-    case 'scanTo':    return [def.sentinel, ...def.skip]
+    case 'scanTo':    return [
+      def.sentinel,
+      ...def.skip,
+      ...(def.recoverAt === undefined ? [] : [def.recoverAt]),
+      ...(def.stopAt === undefined ? [] : [def.stopAt]),
+    ]
     case 'routed':    return def.fallback ? [def.fallback] : []
     case 'lazy':
     case 'literal':
@@ -584,7 +589,7 @@ class Serializer {
       case 'field':     return `field(${JSON.stringify(def.name)}, ${kid(def.parser)})`
       case 'expect':    return `expect(${kid(def.parser)}${def.label !== undefined ? `, ${JSON.stringify(def.label)}` : ''})`
       case 'scanTo':
-        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(', ')}]${def.raw ? ', raw: true' : ''}, orEOF: ${def.orEOF} })`
+        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(', ')}]${def.raw ? ', raw: true' : ''}, orEOF: ${def.orEOF}${def.recoverAt === undefined ? '' : `, recoverAt: ${kid(def.recoverAt)}`}${def.stopAt === undefined ? '' : `, stopAt: ${kid(def.stopAt)}`} })`
       case 'transform': {
         if (def.fnSrc === undefined) throw new Unserializable('transform without fnSrc')
         // `_tf` sets `_def.fnSrc` so re-lowering INLINES the callback (a plain

package/src/compiler/token-alphabet.ts

@@ -1319,7 +1319,7 @@ export function tokenChildren(
   const out: Combinator<unknown>[] = []
   const push = (v: Combinator<unknown> | undefined): void => { if (v !== undefined) out.push(v) }
   const rec = d as unknown as Record<string, unknown>
-  for (const k of ['parser', 'main', 'skipped', 'separator', 'selector', 'sentinel', 'fallback', 'otherwise', 'triviaParser']) {
+  for (const k of ['parser', 'main', 'skipped', 'separator', 'selector', 'sentinel', 'recoverAt', 'stopAt', 'fallback', 'otherwise', 'triviaParser']) {
     const v = rec[k]
     if (v !== null && typeof v === 'object' && '_def' in (v as object)) push(v as Combinator<unknown>)
   }

package/src/coverage.ts

@@ -359,7 +359,13 @@ function coverageEntry(entry: Combinator<unknown>, collector: GrammarCoverageCol
         case 'guard': return gate(def.predicate)
         case 'withCtx': return withCtx(def.extra, build(def.parser))
         case 'expect': return expect(build(def.parser), def.label)
-        case 'scanTo': return scanTo(build(def.sentinel), { skip: def.skip.map(build), orEOF: def.orEOF })
+        case 'scanTo': return scanTo(build(def.sentinel), {
+          skip: def.skip.map(build),
+          raw: def.raw,
+          orEOF: def.orEOF,
+          ...(def.recoverAt === undefined ? {} : { recoverAt: build(def.recoverAt) }),
+          ...(def.stopAt === undefined ? {} : { stopAt: build(def.stopAt) }),
+        })
         // Zero-width assertion with no coverage-bearing child; reuse it verbatim so
         // the rebuilt sequence still recognises the boundary marker.
         case 'adjacency': return parser

package/src/cst/reflection.ts

@@ -58,7 +58,12 @@ function childrenOf(def: ParserDef): readonly Combinator<unknown>[] {
     case 'sepBy':
       return [def.parser, def.separator]
     case 'scanTo':
-      return [def.sentinel, ...def.skip]
+      return [
+        def.sentinel,
+        ...def.skip,
+        ...(def.recoverAt === undefined ? [] : [def.recoverAt]),
+        ...(def.stopAt === undefined ? [] : [def.stopAt]),
+      ]
     case 'routed':
       return def.fallback ? [def.fallback] : []
     case 'literal':

package/src/table/assemble.ts

@@ -487,6 +487,8 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
   for (const s of prog.scans ?? []) {
     for (const r of s.skip) labelExtraIps.push(r[0])
     if (s.sentinel !== undefined) labelExtraIps.push(s.sentinel[0])
+    if (s.recoverAt !== undefined) labelExtraIps.push(s.recoverAt[0])
+    if (s.stopAt !== undefined) labelExtraIps.push(s.stopAt[0])
   }
   for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0])
   const closureLabels = computeSiteLabels(
@@ -3659,6 +3661,8 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     for (const s of prog.scans ?? []) {
       for (const r of s.skip) extraIps.push(r[0])
       if (s.sentinel !== undefined) extraIps.push(s.sentinel[0])
+      if (s.recoverAt !== undefined) extraIps.push(s.recoverAt[0])
+      if (s.stopAt !== undefined) extraIps.push(s.stopAt[0])
     }
     for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0])
     const roots = [...Object.values(prog.rules), ...extraIps]
@@ -3855,7 +3859,13 @@ export function assemble(t: ResolvedTable, prog: TableProgram, cfg: RunCfg): Ass
     const sentDef: ParserDef | undefined = typeof s.sent === 'string'
       ? { tag: 'literal', value: s.sent, caseInsensitive: false } as unknown as ParserDef
       : undefined
-    scansArr.push(scanTo(subtreeComb(s.sentinel!, sentDef), { skip, raw, orEOF: (s.flags & 2) !== 0 }) as Combinator<unknown>)
+    scansArr.push(scanTo(subtreeComb(s.sentinel!, sentDef), {
+      skip,
+      raw,
+      orEOF: (s.flags & 2) !== 0,
+      ...(s.recoverAt === undefined ? {} : { recoverAt: subtreeComb(s.recoverAt) }),
+      ...(s.stopAt === undefined ? {} : { stopAt: subtreeComb(s.stopAt) }),
+    }) as Combinator<unknown>)
   }
   const scans: readonly Combinator<unknown>[] = scansArr
 

package/src/table/emit.ts

@@ -104,6 +104,8 @@ function emitRef(r: import('./program.ts').SubtreeRef): string {
 function emitScanSpec(s: import('./program.ts').ScanSpec): string {
   const parts = [`kind:${s.kind}`, `flags:${s.flags}`, `skip:[${s.skip.map(emitRef).join(',')}]`]
   if (s.sentinel !== undefined) parts.push(`sentinel:${emitRef(s.sentinel)}`)
+  if (s.recoverAt !== undefined) parts.push(`recoverAt:${emitRef(s.recoverAt)}`)
+  if (s.stopAt !== undefined) parts.push(`stopAt:${emitRef(s.stopAt)}`)
   if (s.sent !== undefined) parts.push(`sent:${s.sent === null ? 'null' : jsString(s.sent)}`)
   if (s.open !== undefined) parts.push(`open:${jsString(s.open)}`)
   if (s.close !== undefined) parts.push(`close:${jsString(s.close)}`)
@@ -197,6 +199,8 @@ function emitAssemblies(prog: TableProgram, cfgs: readonly RunCfg[]): string[] {
   for (const s of prog.scans ?? []) {
     for (const r of s.skip) extraIps.push(r[0])
     if (s.sentinel !== undefined) extraIps.push(s.sentinel[0])
+    if (s.recoverAt !== undefined) extraIps.push(s.recoverAt[0])
+    if (s.stopAt !== undefined) extraIps.push(s.stopAt[0])
   }
   for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0])
 

package/src/table/encode.ts

@@ -539,7 +539,9 @@ class Encoder {
   private followClass(parsers: readonly Combinator<unknown>[], i: number): number {
     let fs: FirstSet = { kind: 'empty' }
     const rr = this.refResolver()
-    for (let j = i + 1; j < parsers.length; j++) fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr))
+    for (let j = i + 1; j < parsers.length; j++) {
+      fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr, this.activeTrivia))
+    }
     return this.charClass(fs)
   }
 
@@ -779,7 +781,7 @@ class Encoder {
    */
   private subtree(c: Combinator<unknown>): SubtreeRef {
     const ip = this.node(c).ip
-    const fs = firstSetOf(c, new Set(), this.refResolver())
+    const fs = firstSetOf(c, new Set(), this.refResolver(), this.activeTrivia)
     return [ip, fs.kind === 'empty' ? -2 : this.charClass(fs)]
   }
 
@@ -1003,6 +1005,8 @@ class Encoder {
         flags: (d.raw ? 1 : 0) | (d.orEOF ? 2 : 0),
         skip: d.skip.map(c => this.subtree(c)),
         sentinel: this.subtree(d.sentinel),
+        ...(d.recoverAt === undefined ? {} : { recoverAt: this.subtree(d.recoverAt) }),
+        ...(d.stopAt === undefined ? {} : { stopAt: this.subtree(d.stopAt) }),
         sent: sentDef.tag === 'literal' ? sentDef.value : null,
       }))
     }
@@ -1168,7 +1172,7 @@ class Encoder {
         // the O(1) table (`exclusive`) or falls to the ordered per-arm path.
         // Arm ORDER is preserved on both, which is what makes this a PEG-safe
         // change rather than a reordering.
-        const finalChoice = classifyFinalChoice(arms, rr)
+        const finalChoice = classifyFinalChoice(arms, rr, this.activeTrivia)
         // attempt() preserves its child's success language, but the broad
         // classifier deliberately treats the transaction as nullable/unknown so
         // it can never by itself authorize exclusive one-arm selection. Recover
@@ -1180,7 +1184,7 @@ class Encoder {
           if (!finalChoice.nullable[i]) return undefined
           const def = arm._def as ParserDef
           if (def.tag !== 'attempt' || matchesEmpty(def.parser, new Set(), rr)) return undefined
-          return firstSetOf(def.parser, new Set(), rr)
+          return firstSetOf(def.parser, new Set(), rr, this.activeTrivia)
         })
         const gateFirst = finalChoice.firstSets.map((first, i) => transactionalFirst[i] ?? first)
         const classes = gateFirst.map((first, i) => finalChoice.nullable[i] && transactionalFirst[i] === undefined
@@ -1239,7 +1243,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.existingCharClass(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
@@ -1274,7 +1278,7 @@ class Encoder {
         if (this.rec) {
           return this.emit(
             OP_REP, child, d.min, d.max ?? -1, sep, flags,
-            this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver())),
+            this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver(), this.activeTrivia)),
           )
         }
         return d.min >= 2
@@ -1411,7 +1415,7 @@ class Encoder {
         // 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())
+          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
           : d.parser._meta.firstSet
         if (fs.kind === 'any') return body
         const cls = this.charClass(fs)
@@ -1605,7 +1609,7 @@ class Encoder {
         // 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())
+          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
           : d.parser._meta.firstSet
         if (fs.kind === 'any' || matchesEmpty(d.parser)) return inner
         const cls = this.charClass(fs)
@@ -1762,6 +1766,8 @@ class Encoder {
     const refs: SubtreeRef[] = []
     for (const s of this.scans) {
       if (s.sentinel !== undefined) refs.push(s.sentinel)
+      if (s.recoverAt !== undefined) refs.push(s.recoverAt)
+      if (s.stopAt !== undefined) refs.push(s.stopAt)
       refs.push(...s.skip)
     }
     for (const set of this.scanSkipSets) refs.push(...set)
@@ -1782,6 +1788,8 @@ class Encoder {
       ...s,
       skip: s.skip.map(res),
       ...(s.sentinel === undefined ? {} : { sentinel: res(s.sentinel) }),
+      ...(s.recoverAt === undefined ? {} : { recoverAt: res(s.recoverAt) }),
+      ...(s.stopAt === undefined ? {} : { stopAt: res(s.stopAt) }),
     }))
     this.scanSkipSets = this.scanSkipSets.map(set => set.map(res))
   }

package/src/table/exec.ts

@@ -1666,7 +1666,13 @@ function makeDriver(
     const sentDef: ParserDef | undefined = typeof s.sent === 'string'
       ? { tag: 'literal', value: s.sent, caseInsensitive: false } as unknown as ParserDef
       : undefined
-    return scanTo(subtreeComb(s.sentinel!, sentDef), { skip, raw, orEOF: (s.flags & 2) !== 0 }) as Combinator<unknown>
+    return scanTo(subtreeComb(s.sentinel!, sentDef), {
+      skip,
+      raw,
+      orEOF: (s.flags & 2) !== 0,
+      ...(s.recoverAt === undefined ? {} : { recoverAt: subtreeComb(s.recoverAt) }),
+      ...(s.stopAt === undefined ? {} : { stopAt: subtreeComb(s.stopAt) }),
+    }) as Combinator<unknown>
   })
 
   const scanSkip: readonly (readonly Combinator<unknown>[])[] =

package/src/table/program.ts

@@ -251,6 +251,8 @@ export type ScanSpec = {
   readonly flags: number
   readonly skip: readonly SubtreeRef[]
   readonly sentinel?: SubtreeRef
+  readonly recoverAt?: SubtreeRef
+  readonly stopAt?: SubtreeRef
   readonly sent?: string | null
   readonly open?: string
   readonly close?: string

package/src/types.ts

@@ -107,7 +107,7 @@ export type ParserDef =
   // `scanSkip` are PREPENDED at parse/compile time (explicit skip EXTENDS the
   // ambient default). `raw`: hard opt-out — skip nothing ambiently, restoring the
   // pre-ambient raw byte-walk.
-  | { tag: 'scanTo';   sentinel: Combinator<unknown>; skip: Combinator<unknown>[]; raw: boolean; orEOF: boolean }
+  | { tag: 'scanTo';   sentinel: Combinator<unknown>; skip: Combinator<unknown>[]; raw: boolean; orEOF: boolean; recoverAt?: Combinator<unknown>; stopAt?: Combinator<unknown> }
   | { tag: 'keywords'; words: readonly string[]; caseInsensitive: boolean; boundary: string | undefined }
   | { tag: 'unknown' }
 

package/src/version.ts

@@ -13,4 +13,4 @@
  * 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 const PARSEMAN_VERSION = '0.50.6'
+export const PARSEMAN_VERSION = '0.51.0'