parseman 0.50.0 → 0.50.3

package/src/combinators/repeat.ts

@@ -1,9 +1,10 @@
-import type { Combinator, ParseContext, ParseResult, ParserMeta } from '../types.ts'
-import { advanceTrivia, commitTriviaScan, needsDeferredTriviaCommit, rollbackTrivia, saveTriviaMark, scanTriviaCompact } from './trivia-skip.ts'
+import type { Combinator, ParseContext, ParseOk, ParseResult, ParserMeta } from '../types.ts'
+import { advanceTrivia, commitTriviaScan, needsDeferredTriviaCommit, needsTriviaRollback, rollbackTrivia, saveTriviaMark, scanTriviaCompact } from './trivia-skip.ts'
 import { matchesEmpty, startsFirstSet } from './first-set.ts'
 import { deriveExpected } from './expect.ts'
 import { matchesAt, orSentinel, recoverScan, captureError } from '../recovery/scan.ts'
 import { demoteCapturedToRaw } from '../cst/capture-buffer.ts'
+import { scalarOf, type ScalarParser } from './scalar.ts'
 
 /**
  * Parse one repetition item at `cur`, first skipping (and, in capture mode,
@@ -13,7 +14,7 @@ import { demoteCapturedToRaw } from '../cst/capture-buffer.ts'
  * if the item then fails or makes no progress the trivia is rolled back and the
  * loop stops (the trivia is trailing and belongs to the enclosing context).
  *
- * Returns the item value + end position, the underlying failure (so oneOrMore
+ * Returns the successful child result, the underlying failure (so oneOrMore
  * can propagate a first-item failure), or 'stop'.
  *
  * `mandatory` marks an item `min` REQUIRES rather than one the greedy loop is
@@ -31,8 +32,9 @@ function repItem<T>(
   ctx: ParseContext,
   guardable: boolean,
   mandatory: boolean,
-): { value: T; end: number } | { fail: ParseResult<T>; failPos: number } | 'stop' {
-  const mark = saveTriviaMark(ctx)
+  rollbackNeeded: boolean,
+): ParseOk<T> | { fail: ParseResult<T>; failPos: number } | 'stop' {
+  const mark = rollbackNeeded ? saveTriviaMark(ctx) : undefined
   let pos = cur
   if (ctx.trivia) {
     if (needsDeferredTriviaCommit(ctx)) {
@@ -47,7 +49,7 @@ function repItem<T>(
   // is the operative word: a `mandatory` item is not speculative, so it is
   // attempted at EOF like the first item is, and a NULLABLE one matches there.
   if (pos >= input.length && !mandatory) {
-    rollbackTrivia(ctx, mark)
+    if (mark !== undefined) rollbackTrivia(ctx, mark)
     return 'stop'
   }
   // First-set fast-path (mirrors emitMany's codegen guard): a body that can't match
@@ -58,12 +60,12 @@ function repItem<T>(
   // probe or tolerant recovery, where a swallowed failure still feeds the probe /
   // triggers resync (matching the codegen guard's `!ctx.recovery` gate).
   if (guardable && ctx._probe === undefined && !ctx._tolerant && !startsFirstSet(combinator, input, pos)) {
-    rollbackTrivia(ctx, mark)
+    if (mark !== undefined) rollbackTrivia(ctx, mark)
     return 'stop'
   }
   const result = combinator.parse(input, pos, ctx)
   if (!result.ok) {
-    rollbackTrivia(ctx, mark)
+    if (mark !== undefined) rollbackTrivia(ctx, mark)
     if (result.committed) return { fail: result, failPos: pos }
     // Surface the POST-trivia position where the element actually failed. The
     // tolerant recovery guard must check the sync token there — not at `cur`,
@@ -78,10 +80,10 @@ function repItem<T>(
   // string with any number of them, so a `{ min: n }` prefix takes the n-item
   // derivation. It cannot spin — the prefix is exactly `n` long.
   if (result.span.end === pos && !mandatory) {
-    rollbackTrivia(ctx, mark)
+    if (mark !== undefined) rollbackTrivia(ctx, mark)
     return 'stop'
   }
-  return { value: result.value, end: result.span.end }
+  return result
 }
 
 export type RepeatOptions = {
@@ -110,6 +112,25 @@ function resolveBounds(what: string, opts: { min?: number; max?: number }): { mi
   return { min, max }
 }
 
+function repeatScalarTail<T>(
+  combinator: Combinator<T>, child: ScalarParser, input: string, cur: number,
+  ctx: ParseContext, guardable: boolean, values: T[] | undefined, remaining: number,
+): number {
+  while (cur < input.length && remaining > 0) {
+    let itemPos = cur
+    if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx)
+    if (itemPos >= input.length) break
+    if (guardable && !startsFirstSet(combinator, input, itemPos)) break
+    const end = child(input, itemPos, ctx)
+    if (end <= itemPos) break
+    if (values !== undefined) values.push(ctx._sv as T)
+    cur = end
+    remaining--
+  }
+  ctx._sv = values
+  return cur
+}
+
 /**
  * Repetition: `item*` by default, bounded by `{ min, max }` (both count ITEMS).
  *
@@ -137,20 +158,25 @@ export function many<T>(combinator: Combinator<T>, opts: RepeatOptions = {}): Co
   let expected: string[] | undefined
   // A non-nullable body can be first-set-gated per loop iteration (see repItem).
   const guardable = combinator._meta.firstSet.kind !== 'any' && !matchesEmpty(combinator)
+  const scalarChild = scalarOf(combinator)
+  const parseScalar = (input: string, pos: number, ctx: ParseContext): number =>
+    repeatScalarTail(combinator, scalarChild, input, pos, ctx, guardable, def.valueUnused ? undefined : [], max)
 
   return {
     _tag: 'many',
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {
       // When the aggregate is never observed (markUnusedValues), skip the array:
       // items still parse and self-capture into the enclosing node's children.
       const values: T[] | undefined = def.valueUnused ? undefined : []
+      const rollbackNeeded = needsTriviaRollback(ctx)
       let cur = pos
       let count = 0
       while (cur < input.length) {
         if (count >= max) break
-        const item = repItem(combinator, input, cur, ctx, guardable, false)
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded)
         if (item === 'stop') break
         if ('fail' in item) {
           if (!item.fail.ok && item.fail.committed) return item.fail
@@ -175,7 +201,7 @@ export function many<T>(combinator: Combinator<T>, opts: RepeatOptions = {}): Co
         }
         if (values !== undefined) values.push(item.value)
         count++
-        cur = item.end
+        cur = item.span.end
       }
       // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
       return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }
@@ -207,11 +233,27 @@ function atLeast<T>(combinator: Combinator<T>, min: number, max: number): Combin
   let expected: string[] | undefined
   // A non-nullable body can be first-set-gated per loop iteration (see repItem).
   const guardable = combinator._meta.firstSet.kind !== 'any' && !matchesEmpty(combinator)
+  const scalarChild = scalarOf(combinator)
+  const parseScalar = (input: string, pos: number, ctx: ParseContext): number => {
+    let cur = scalarChild(input, pos, ctx)
+    if (cur < 0) return cur
+    const values: T[] | undefined = def.valueUnused ? undefined : [ctx._sv as T]
+    for (let count = 1; count < min; count++) {
+      let itemPos = cur
+      if (ctx.trivia) itemPos = advanceTrivia(input, cur, ctx)
+      const end = scalarChild(input, itemPos, ctx)
+      if (end < 0) return ~cur
+      cur = end
+      if (values !== undefined) values.push(ctx._sv as T)
+    }
+    return repeatScalarTail(combinator, scalarChild, input, cur, ctx, guardable, values, max - min)
+  }
 
   return {
     _tag: 'oneOrMore',
     _meta: meta,
     _def: def,
+    _parseScalar: parseScalar,
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {
       // First item is mandatory (parsed at pos directly — leading trivia is the
       // enclosing context's responsibility); subsequent items skip leading trivia.
@@ -219,6 +261,7 @@ function atLeast<T>(combinator: Combinator<T>, min: number, max: number): Combin
       if (!first.ok) return first
       // Aggregate skipped when never observed (see `many`).
       const values: T[] | undefined = def.valueUnused ? undefined : [first.value]
+      const rollbackNeeded = needsTriviaRollback(ctx)
       let cur = first.span.end
       let count = 1
       // Mandatory items 2..min (only entered for min > 1) — each failure propagates,
@@ -227,7 +270,7 @@ function atLeast<T>(combinator: Combinator<T>, min: number, max: number): Combin
       // two loop-termination stops: a required item is attempted at its position
       // whatever is there, and counts whatever its width.
       while (count < min) {
-        const item = repItem(combinator, input, cur, ctx, guardable, true)
+        const item = repItem(combinator, input, cur, ctx, guardable, true, rollbackNeeded)
         if (item === 'stop' || 'fail' in item) {
           if (item !== 'stop' && !item.fail.ok && item.fail.committed) return item.fail
           // Anchored at `cur` — the furthest position the repeat reached — not at
@@ -239,12 +282,12 @@ function atLeast<T>(combinator: Combinator<T>, min: number, max: number): Combin
           return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } }
         }
         if (values !== undefined) values.push(item.value)
-        cur = item.end
+        cur = item.span.end
         count++
       }
       while (cur < input.length) {
         if (count >= max) break
-        const item = repItem(combinator, input, cur, ctx, guardable, false)
+        const item = repItem(combinator, input, cur, ctx, guardable, false, rollbackNeeded)
         if (item === 'stop') break
         if ('fail' in item) {
           if (!item.fail.ok && item.fail.committed) return item.fail
@@ -262,7 +305,7 @@ function atLeast<T>(combinator: Combinator<T>, min: number, max: number): Combin
         }
         if (values !== undefined) values.push(item.value)
         count++
-        cur = item.end
+        cur = item.span.end
       }
       // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
       return { ok: true, value: (values ?? undefined) as T[], span: { start: pos, end: cur } }
@@ -277,11 +320,23 @@ export function optional<T>(combinator: Combinator<T>): Combinator<T | null> {
     isTrivia: false,
   }
   const firstSetSkippable = !matchesEmpty(combinator)
+  const scalarChild = scalarOf(combinator)
+  const parseScalar = (input: string, pos: number, ctx: ParseContext): number => {
+    if (firstSetSkippable && !startsFirstSet(combinator, input, pos)) {
+      ctx._sv = null
+      return pos
+    }
+    const end = scalarChild(input, pos, ctx)
+    if (end >= 0) return end
+    ctx._sv = null
+    return pos
+  }
 
   return {
     _tag: 'optional',
     _meta: meta,
     _def: { tag: 'optional', parser: combinator as Combinator<unknown> },
+    _parseScalar: parseScalar,
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<T | null> {
       if (firstSetSkippable && ctx._probe === undefined && !startsFirstSet(combinator, input, pos)) {
         return { ok: true, value: null, span: { start: pos, end: pos } }
@@ -412,6 +467,43 @@ export function sepBy<T, S>(
     expected ??= deriveExpected(combinator)
     return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: at, end: at } }
   }
+  const scalarExpected = deriveExpected(combinator)
+  const scalarChild = scalarOf(combinator)
+  const scalarSeparator = scalarOf(separator)
+  const parseScalar = (input: string, pos: number, ctx: ParseContext): number => {
+    let cur = scalarChild(input, pos, ctx)
+    if (cur < 0) {
+      if (min >= 1) {
+        ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag]
+        return ~pos
+      }
+      ctx._sv = []
+      return pos
+    }
+    const values = [ctx._sv as T]
+    while (values.length < max && (cur < input.length || values.length < min)) {
+      const beforeSeparator = cur
+      let separatorPos = cur
+      if (ctx.trivia) separatorPos = advanceTrivia(input, cur, ctx)
+      const separatorEnd = scalarSeparator(input, separatorPos, ctx)
+      if (separatorEnd < 0) break
+      let itemPos = separatorEnd
+      if (ctx.trivia) itemPos = advanceTrivia(input, itemPos, ctx)
+      const itemEnd = scalarChild(input, itemPos, ctx)
+      if (itemEnd < 0) {
+        cur = trailing === 'allow' ? separatorEnd : beforeSeparator
+        break
+      }
+      values.push(ctx._sv as T)
+      cur = itemEnd
+    }
+    if (values.length < min) {
+      ctx._fx = scalarExpected.length > 0 ? scalarExpected : [combinator._tag]
+      return ~cur
+    }
+    ctx._sv = values
+    return cur
+  }
 
   return {
     _tag: 'sepBy',
@@ -425,6 +517,7 @@ export function sepBy<T, S>(
       // this option surface already; parity is held by test/parity, not by hope.
       ...(keepSeparators ? { keepSeparators: true } : {}),
     },
+    _parseScalar: keepSeparators ? undefined : parseScalar,
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<T[]> {
       const first = combinator.parse(input, pos, ctx)
       const values: T[] = []

package/src/combinators/scalar.ts

@@ -0,0 +1,30 @@
+import type { Combinator, ParseContext } from '../types.ts'
+
+export type ScalarParser = (input: string, pos: number, ctx: ParseContext) => number
+
+const SCALAR_TAG = /^(?:literal|regex|keywords|sequence|choice|many|oneOrMore|optional|transform|trivia|grammar|sepBy|lazy)$/
+
+export function scalarOf<T>(combinator: Combinator<T>): ScalarParser {
+  return combinator._parseScalar!
+}
+
+function scalarTree(parser: Combinator<unknown>, seen: Set<Combinator<unknown>>): boolean {
+  if (seen.has(parser)) return true
+  if (parser._parseScalar === undefined) return false
+  seen.add(parser)
+  const def = parser._def
+  if (!SCALAR_TAG.test(def.tag)) return false
+  if ('parsers' in def && !def.parsers.every(child => scalarTree(child, seen))) return false
+  if ('parser' in def && !scalarTree(def.parser, seen)) return false
+  if ('separator' in def && !scalarTree(def.separator, seen)) return false
+  return def.tag !== 'lazy' || scalarTree(def.thunk(), seen)
+}
+
+/** Select the strict value-only ABI only when the complete root is in its family. */
+export function scalarRootOf<T>(combinator: Combinator<T>): ScalarParser | undefined {
+  const scalar = combinator._parseScalar
+  const def = combinator._def
+  return scalar !== undefined && def.tag === 'grammar' && scalarTree(def.parser, new Set())
+    ? scalar
+    : undefined
+}

package/src/combinators/sequence.ts

@@ -1,5 +1,5 @@
 import type { Combinator, ParseContext, ParseResult, ParserMeta, ParseFail } from '../types.ts'
-import { sequenceFirstSet, firstSetOf, union } from './first-set.ts'
+import { sequenceFirstSet, firstSetOf, matchesEmpty, union } from './first-set.ts'
 import {
   advanceTrivia, commitTriviaScan, needsDeferredTriviaCommit, rollbackScannedTriviaAt,
   scanTriviaCompact,
@@ -7,6 +7,7 @@ import {
 import { cstTlLen } from '../cst/capture-buffer.ts'
 import { firstSetSentinel } from '../recovery/scan.ts'
 import { adjacencyFail, adjacencyOf, holdsAdjacency, type AdjacencyDef } from './adjacency.ts'
+import { scalarOf } from './scalar.ts'
 
 type UnwrapParsers<T extends Combinator<unknown>[]> = {
   [K in keyof T]: T[K] extends Combinator<infer U> ? U : never
@@ -36,6 +37,11 @@ export function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[
     ;(adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a
   }
   const hasAdjacency = adjacency !== null
+  const strictArity = !hasAdjacency
+    && ((parsers.length === 2 && !matchesEmpty(parsers[1]!))
+      || (parsers.length === 3 && parsers.every(p => !matchesEmpty(p))))
+    ? parsers.length
+    : 0
 
   const meta: ParserMeta = {
     // Union through the nullable prefix — a leading optional()/many() lets a later
@@ -47,194 +53,103 @@ export function sequence<T extends [Combinator<unknown>, ...Combinator<unknown>[
 
   const def: { tag: 'sequence'; parsers: Combinator<unknown>[]; valueUnused?: boolean } =
     { tag: 'sequence', parsers: parsers as Combinator<unknown>[] }
-
-  // Automatic recovery-sync inference, built lazily on the first tolerant parse and
-  // never touched on the strict path: followSentinels[i] matches (zero-width) when
-  // the input could start any term AFTER i, so a list nested in term i can resync
-  // to this sequence's enclosing delimiter with NO grammar annotation. This is the
-  // whole of "recovery config" — derived from structure, not authored.
-  let followSentinels: (Combinator<null> | null)[] | undefined
-
-  // Tolerant twin of the strict loop: identical term-parsing, but around each term
-  // it publishes the inferred follow sentinel into ctx._sync so a nested list can
-  // resync to this sequence's enclosing delimiter. Cold path (tolerant only).
-  function parseTolerant(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {
-    followSentinels ??= parsers.map((_, i) => {
-      // A nested list can resync to the start of ANY term that follows it here, so
-      // union every following term's first set (not just up to the first
-      // non-nullable one — a mandatory middle term must not hide a later close).
-      const fs = parsers.slice(i + 1).reduce<ReturnType<typeof firstSetOf>>(
-        (acc, p) => union(acc, firstSetOf(p)),
-        { kind: 'empty' },
-      )
-      return firstSetSentinel(fs)
-    })
-    const values: unknown[] | undefined = def.valueUnused ? undefined : []
+  const scalarParsers = parsers.map(scalarOf)
+  const parseScalar = (input: string, pos: number, ctx: ParseContext): number => {
     let cur = pos
-    const inheritedSync = ctx._sync
-    try {
-      for (let i = 0; i < parsers.length; i++) {
-        // Publish this term's follow set (or keep the inherited sync when the local
-        // follow isn't usable, e.g. the last term or an `any` first set).
-        ctx._sync = followSentinels[i] ?? inheritedSync
-        const adj = adjacency === null ? null : adjacency[i]
-        if (adj) {
-          if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj)
-          if (values !== undefined) values.push(null)
-          continue
-        }
-        if (ctx.trivia && i > 0) {
-          const mTlog = cstTlLen(ctx)
-          const mLog = ctx._triviaLog?.length ?? 0
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0
-          let scanEnd: number
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx))
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx)
-          }
-          const scanTlog = cstTlLen(ctx)
-          const scanLog = ctx._triviaLog?.length ?? 0
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0
-          const result = parsers[i]!.parse(input, scanEnd, ctx)
-          if (!result.ok) return result as ParseFail
-          if (result.span.end > scanEnd) cur = result.span.end
-          else rollbackScannedTriviaAt(
-            ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog,
-          )
-          if (values !== undefined) values.push(result.value)
-          continue
-        }
-        const result = parsers[i]!.parse(input, cur, ctx)
-        if (!result.ok) return result as ParseFail
-        if (values !== undefined) values.push(result.value)
-        cur = result.span.end
+    if (strictArity !== 0) {
+      cur = scalarParsers[0]!(input, cur, ctx)
+      if (cur < 0) return cur
+      const first = ctx._sv
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx)
+      cur = scalarParsers[1]!(input, cur, ctx)
+      if (cur < 0) return cur
+      const second = ctx._sv
+      if (strictArity === 2) {
+        ctx._sv = def.valueUnused ? undefined : [first, second]
+        return cur
       }
-    } finally {
-      ctx._sync = inheritedSync
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx)
+      cur = scalarParsers[2]!(input, cur, ctx)
+      if (cur < 0) return cur
+      ctx._sv = def.valueUnused ? undefined : [first, second, ctx._sv]
+      return cur
     }
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: (values ?? undefined) as UnwrapParsers<T>,
-      span: { start: pos, end: cur },
-    }
-  }
 
-  // Strict twin of the loop below, for the (rare) sequence that carries an adjacency
-  // assertion. FORKED rather than branched inline so the ordinary strict loop — the
-  // hot path of every grammar — keeps exactly the instructions it had before.
-  function parseAdjacent(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {
     const values: unknown[] | undefined = def.valueUnused ? undefined : []
-    let cur = pos
-
-    for (let i = 0; i < parsers.length; i++) {
-      const adj = adjacency![i]
-      if (adj) {
-        // Assert over the gap at `cur` and move nothing. The NEXT term re-scans the
-        // same gap and owns the commit/rewind decision, so the tree, the spans and
-        // the trivia log are byte-identical to the same sequence without the marker.
-        if (!holdsAdjacency(input, cur, ctx, adj)) return adjacencyFail(cur, adj)
-        if (values !== undefined) values.push(null)
-        continue
-      }
-      if (ctx.trivia && i > 0) {
-        let scanEnd: number
-        const mTlog = cstTlLen(ctx)
-        const mLog = ctx._triviaLog?.length ?? 0
-        const mRootLog = ctx._rootTriviaLog?.length ?? 0
-        if (needsDeferredTriviaCommit(ctx)) {
-          scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx))
-        } else {
-          scanEnd = advanceTrivia(input, cur, ctx)
-        }
-        const scanTlog = cstTlLen(ctx)
-        const scanLog = ctx._triviaLog?.length ?? 0
-        const scanRootLog = ctx._rootTriviaLog?.length ?? 0
-        const result = parsers[i]!.parse(input, scanEnd, ctx)
-        if (!result.ok) return result as ParseFail
-        if (result.span.end > scanEnd) cur = result.span.end
-        else rollbackScannedTriviaAt(
-          ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog,
-        )
-        if (values !== undefined) values.push(result.value)
-        continue
-      }
-      const result = parsers[i]!.parse(input, cur, ctx)
-      if (!result.ok) return result as ParseFail
-      if (values !== undefined) values.push(result.value)
-      cur = result.span.end
-    }
-
-    return {
-      ok: true,
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-      value: (values ?? undefined) as UnwrapParsers<T>,
-      span: { start: pos, end: cur },
+    for (let i = 0; i < scalarParsers.length; i++) {
+      let termPos = cur
+      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx)
+      const end = scalarParsers[i]!(input, termPos, ctx)
+      if (end < 0) return end
+      if (values !== undefined) values.push(ctx._sv)
+      if (end > termPos || termPos === cur) cur = end
     }
+    ctx._sv = values
+    return cur
   }
 
+  // Recovery follow sets are derived only when the general family runs tolerantly.
+  let followSentinels: (Combinator<null> | null)[] | undefined
+
   return {
     _tag: 'sequence',
     _meta: meta,
     _def: def,
+    _parseScalar: hasAdjacency ? undefined : parseScalar,
     parse(input: string, pos: number, ctx: ParseContext): ParseResult<UnwrapParsers<T>> {
-      // One cold branch: in tolerant mode publish each term's follow-set as ctx._sync
-      // so a nested list resyncs to the enclosing delimiter (dynamic scoping through
-      // refs carries this across rule boundaries automatically). The strict loop
-      // below is byte-identical to a parser with no recovery.
-      if (ctx._tolerant) return parseTolerant(input, pos, ctx)
-      if (hasAdjacency) return parseAdjacent(input, pos, ctx)
-
-      // Skip the tuple when it's never observed (markUnusedValues): terms still
-      // parse (and self-capture) — only the array of their values is elided.
+      const tolerant = ctx._tolerant === true
+      if (tolerant) {
+        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
+          parsers.slice(i + 1).reduce<ReturnType<typeof firstSetOf>>(
+            (set, parser) => union(set, firstSetOf(parser)), { kind: 'empty' },
+          ),
+        ))
+      }
+      const inheritedSync = ctx._sync
+      const deferredTrivia = needsDeferredTriviaCommit(ctx)
       const values: unknown[] | undefined = def.valueUnused ? undefined : []
       let cur = pos
-
-      for (let i = 0; i < parsers.length; i++) {
-        if (ctx.trivia && i > 0) {
-          // Skip trivia between terms, but only *consume* it for span purposes if
-          // this term actually matches content past the trivia. A term that matches
-          // empty (optional/many/lookahead) leaves the trivia for the enclosing rule.
-          let scanEnd: number
-          const mTlog = cstTlLen(ctx)
-          const mLog = ctx._triviaLog?.length ?? 0
-          const mRootLog = ctx._rootTriviaLog?.length ?? 0
-
-          if (needsDeferredTriviaCommit(ctx)) {
-            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx))
-          } else {
-            scanEnd = advanceTrivia(input, cur, ctx)
+      try {
+        for (let i = 0; i < parsers.length; i++) {
+          if (tolerant) ctx._sync = followSentinels![i] ?? inheritedSync
+          const assertion = adjacency?.[i]
+          if (assertion) {
+            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion)
+            if (values !== undefined) values.push(null)
+            continue
           }
-          const scanTlog = cstTlLen(ctx)
-          const scanLog = ctx._triviaLog?.length ?? 0
-          const scanRootLog = ctx._rootTriviaLog?.length ?? 0
-
-          const result = parsers[i]!.parse(input, scanEnd, ctx)
+          let termPos = cur
+          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0
+          const markLog = deferredTrivia ? (ctx._triviaLog?.length ?? 0) : 0
+          const markRootLog = deferredTrivia ? (ctx._rootTriviaLog?.length ?? 0) : 0
+          if (ctx.trivia && i > 0) {
+            termPos = deferredTrivia
+              ? commitTriviaScan(scanTriviaCompact(input, cur, ctx))
+              : advanceTrivia(input, cur, ctx)
+          }
+          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0
+          const scanLog = deferredTrivia ? (ctx._triviaLog?.length ?? 0) : 0
+          const scanRootLog = deferredTrivia ? (ctx._rootTriviaLog?.length ?? 0) : 0
+          const result = parsers[i]!.parse(input, termPos, ctx)
           if (!result.ok) return result as ParseFail
-          if (result.span.end > scanEnd) {
-            cur = result.span.end
-          } else {
+          if (values !== undefined) values.push(result.value)
+          if (result.span.end > termPos || termPos === cur) cur = result.span.end
+          else if (deferredTrivia) {
             rollbackScannedTriviaAt(
-              ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog,
+              ctx, markTlog, scanTlog, markLog, scanLog, markRootLog, scanRootLog,
             )
           }
-          if (values !== undefined) values.push(result.value)
-          continue
         }
-
-        const result = parsers[i]!.parse(input, cur, ctx)
-        if (!result.ok) return result as ParseFail
-        if (values !== undefined) values.push(result.value)
-        cur = result.span.end
+      } finally {
+        if (tolerant) ctx._sync = inheritedSync
       }
-
       return {
         ok: true,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
         value: (values ?? undefined) as UnwrapParsers<T>,
         span: { start: pos, end: cur },
       }
+
     },
   }
 }

package/src/combinators/trivia-skip.ts

@@ -66,6 +66,18 @@ export function needsDeferredTriviaCommit(ctx: ParseContext): boolean {
   return ctx._triviaLog !== undefined || ctx._rootTriviaLog !== undefined || ctx._cstBuf !== undefined || ctx._cstTriviaLog !== undefined
 }
 
+/** True when speculative parsing can write anything `rollbackTrivia` restores. */
+export function needsTriviaRollback(ctx: ParseContext): boolean {
+  return ctx._cstBuf !== undefined
+    || ctx._cstLeaves !== undefined
+    || ctx._cstRawChildren !== undefined
+    || ctx._cstTriviaLog !== undefined
+    || ctx._fields !== undefined
+    || ctx._errors !== undefined
+    || ctx._triviaLog !== undefined
+    || ctx._rootTriviaLog !== undefined
+}
+
 export function saveTriviaMark(ctx: ParseContext): TriviaRollbackMark {
   const m = saveCstMark(ctx)
   return {
@@ -268,7 +280,8 @@ export function advanceTrivia(input: string, cur: number, ctx: ParseContext): nu
   const triviaP = ctx.trivia
   if (!triviaP) return cur
   if (!ctx.trackLines) {
-    const fast = fastTriviaScanner(triviaP)
+    const classified = triviaP._meta.triviaScanner
+    const fast = classified === undefined ? fastTriviaScanner(triviaP) : classified
     if (fast) return fast(input, cur)
     if (ctx.triviaKindLabels) return skipWithLabels(input, cur, ctx)
     const tr = triviaP.parse(input, cur, createDetachedParseContext(ctx.trackLines, ctx.state))

package/src/parse-context.ts

@@ -56,6 +56,7 @@ export function createParseContext(): ParseContext {
     _fe: undefined,
     _fx: undefined,
     _fc: undefined,
+    _sv: undefined,
     _probe: undefined,
     _cstChildren: undefined,
     _cstLeaves: undefined,