parseman 0.55.1 → 0.55.3

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.55.1";
+export declare const PARSEMAN_VERSION = "0.55.3";
 //# sourceMappingURL=version.d.ts.map

package/package.json

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

package/src/analysis/commitment.ts

@@ -441,24 +441,41 @@ export function hasDirectBuildDef(p: Combinator<unknown>, seen: Set<Combinator<u
   }
 }
 
-/** True when `p` can report a committed failure through emitFallible's failure channel. */
+/**
+ * True when `p` can report a committed failure through emitFallible's failure
+ * channel: a `dispatch`, or a shape this analysis cannot see into, is reachable
+ * along `commitFailureSuccessors`' edges.
+ *
+ * `memo` carries exact answers between calls over one graph and one `resolve`;
+ * a caller asking at many sites passes the same map to every call, so the graph
+ * is walked once rather than once per site.
+ */
 export function mayCommitFailure(
   p: Combinator<unknown>,
-  seen: Set<Combinator<unknown>> = new Set(),
   resolve?: RefResolver,
+  memo: Map<Combinator<unknown>, boolean> = new Map(),
 ): boolean {
-  if (seen.has(p)) return false
-  seen.add(p)
+  return reachesMarked(p, node => commitFailureSuccessors(node, resolve), memo)
+}
+
+const NO_EDGES: readonly Combinator<unknown>[] = []
+
+/** `mayCommitFailure`'s edges out of `p`, or `true` when `p` itself can commit. */
+function commitFailureSuccessors(
+  p: Combinator<unknown>,
+  resolve: RefResolver | undefined,
+): readonly Combinator<unknown>[] | true {
   const d = p._def
   switch (d.tag) {
     case 'dispatch':
+    case 'unknown':
       return true
     case 'choice':
     case 'sequence':
-      return d.parsers.some(x => mayCommitFailure(x, seen, resolve))
+      return d.parsers
     // A contained transaction reports every failure uncommitted.
     case 'attempt':
-      return d.contain !== true && mayCommitFailure(d.parser, seen, resolve)
+      return d.contain === true ? NO_EDGES : [d.parser]
     case 'many':
     case 'oneOrMore':
     case 'optional':
@@ -467,32 +484,102 @@ export function mayCommitFailure(
     case 'field':
     case 'grammar':
     case 'node':
-      return mayCommitFailure(d.parser, seen, resolve)
-    case 'sepBy':
-      return mayCommitFailure(d.parser, seen, resolve) || mayCommitFailure(d.separator, seen, resolve)
     case 'token':
     case 'leaf':
-      return mayCommitFailure(d.parser, seen, resolve)
     case 'withCtx':
-      return mayCommitFailure(d.parser, seen, resolve)
+      return [d.parser]
+    case 'sepBy':
+      return [d.parser, d.separator]
     case 'scanTo':
-      return mayCommitFailure(d.sentinel, seen, resolve)
-        || d.skip.some(x => mayCommitFailure(x, seen, resolve))
-        || (d.recoverAt !== undefined && mayCommitFailure(d.recoverAt, seen, resolve))
-        || (d.stopAt !== undefined && mayCommitFailure(d.stopAt, seen, resolve))
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...(d.recoverAt === undefined ? NO_EDGES : [d.recoverAt]),
+        ...(d.stopAt === undefined ? NO_EDGES : [d.stopAt]),
+      ]
     case 'lazy': {
-      try { return mayCommitFailure(d.thunk(), seen, resolve) }
+      try { return [d.thunk()] }
       catch {
         const name = (p as unknown as { _ruleName?: string })._ruleName
         const target = name === undefined ? undefined : resolve?.(name)
-        return target === undefined ? true : mayCommitFailure(target, seen, resolve)
+        return target === undefined ? true : [target]
       }
     }
-    case 'unknown':
-      return true
     default:
-      return false
+      return NO_EDGES
+  }
+}
+
+/**
+ * Whether a MARKED node — one `successors` answers `true` for — is reachable
+ * from `root`.
+ *
+ * Reachability over a cyclic graph, decided with Tarjan's strongly connected
+ * components so that every node the walk enters leaves with its exact answer in
+ * `memo`: the members of one component reach each other, so they share one
+ * answer, settled when the walk returns to the component's first node. A DFS
+ * that instead cuts a cycle at its own ancestor path learns nothing it can keep
+ * about a node whose walk hit the cut; one that keeps a visited set per call
+ * keeps nothing past the call. Shared across calls, `memo` makes every node
+ * entered once however many roots are asked about.
+ *
+ * `memo` must only ever be used with one `successors`: its entries are answers
+ * about that graph.
+ */
+export function reachesMarked<T>(
+  root: T,
+  successors: (node: T) => readonly T[] | true,
+  memo: Map<T, boolean>,
+): boolean {
+  const known = memo.get(root)
+  if (known !== undefined) return known
+  const order = new Map<T, number>()
+  const low: number[] = []
+  const found: boolean[] = []
+  const stack: T[] = []
+  const visit = (node: T): number => {
+    const at = low.length
+    order.set(node, at)
+    low.push(at)
+    found.push(false)
+    stack.push(node)
+    const next = successors(node)
+    if (next === true) found[at] = true
+    else {
+      for (const child of next) {
+        // Settled: a node that reaches a marked node is answered, and so is
+        // every node still above it on the stack, since each reaches it. The
+        // children left unentered stay unmemoized for a later walk to settle.
+        if (found[at]) break
+        const hit = memo.get(child)
+        if (hit !== undefined) {
+          if (hit) found[at] = true
+          continue
+        }
+        const seen = order.get(child)
+        if (seen !== undefined) {
+          // Unmemoized but entered: still on the stack, so in this node's
+          // component. Its answer reaches the component's first node by the
+          // tree edges, not through here.
+          if (seen < low[at]!) low[at] = seen
+          continue
+        }
+        const k = visit(child)
+        if (low[k]! < low[at]!) low[at] = low[k]!
+        if (found[k]) found[at] = true
+      }
+    }
+    if (low[at] === at) {
+      const answer = found[at]!
+      let member: T
+      do {
+        member = stack.pop()!
+        memo.set(member, answer)
+      } while (member !== node)
+    }
+    return at
   }
+  return found[visit(root)]!
 }
 
 /** A leaf-composed imported piece may carry Parseman's own structural balanced

package/src/combinators/choice.ts

@@ -128,8 +128,7 @@ export function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(C
       // could have started here" the in-bounds miss below gives. Falling through to
       // firstMatch instead made this position the ONE place a gated-off arm was
       // dropped from the report — firstMatch `continue`s past it and contributes
-      // nothing — while the in-bounds miss runs `parsers.flatMap` ignoring gates and
-      // DOES name it. Same gate state, same "no arm can match", two different
+      // nothing — while the in-bounds miss names every arm, gates ignored. Same gate state, same "no arm can match", two different
       // answers; codegen and both table drivers only ever gave the union. Accept and
       // reject are untouched: every arm fails at EOF on either path.
       if (disjoint) {
@@ -154,14 +153,13 @@ export function choice<T extends [Combinator<unknown> | GatedArm<unknown>, ...(C
           if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true }
           return { ok: false, expected, span: { start: pos, end: pos } }
         }
-        return {
-          ok: false,
-          expected: parsers.flatMap(p => {
-            const r = p.parse(input, pos, ctx)
-            return r.ok ? [] : r.expected
-          }),
-          span: { start: pos, end: pos },
-        }
+        // No arm's first set holds this character (or the input has ended), so
+        // every arm fails here without reading it. The report is the arms' static
+        // expectations: the set this choice's scalar path and both table drivers
+        // report for the same miss. A completion probe or recovery sink still sees
+        // each arm fail, as it does behind node/attempt/repeat's first-set guards.
+        if (ctx._probe !== undefined || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx)
+        return { ok: false, expected: [...scalarExpected], span: { start: pos, end: pos } }
       }
 
       // ── greedyClassify: run one regex, classify by string equality ─────────

package/src/table/encode.ts

@@ -1,7 +1,7 @@
 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'
-import { capturesLeaf, mayCommitFailure, mayLeavePartialCapture } from '../analysis/commitment.ts'
+import { capturesLeaf, mayCommitFailure, mayLeavePartialCapture, reachesMarked } from '../analysis/commitment.ts'
 import { getCoreLiteralValue } from '../combinators/choice.ts'
 import { deriveExpected } from '../combinators/expect.ts'
 import { assertionFailureExpected, directTerminalFailureExpected } from '../combinators/expected.ts'
@@ -154,6 +154,13 @@ class Encoder {
    * attempt sites reach it.
    */
   private sideWriterMemo = new Map<Combinator<unknown>, boolean>()
+  /**
+   * `mayCommitFailure`'s answers, shared by every choice site for the lifetime
+   * of this `Encoder` — exact for the graph and the `winners` resolver it is
+   * encoding, so the rule graph is walked once per encode rather than once per
+   * choice site.
+   */
+  private commitFailureMemo = new Map<Combinator<unknown>, boolean>()
   labels: readonly string[] | undefined = undefined
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia: Combinator<unknown> | undefined = undefined
@@ -661,65 +668,11 @@ class Encoder {
 
   /**
    * Whether a field, recovered error, interpreted scanner or unresolvable shape
-   * is reachable from `root` — the writer census of `failureNeedsRollback`.
-   *
-   * Reachability over a cyclic graph, decided with Tarjan's strongly connected
-   * components so that every node the walk enters leaves with its exact answer
-   * memoized: the members of one component reach each other, so they share one
-   * answer, settled when the walk returns to the component's first node. A DFS
-   * that instead cuts a cycle at its own ancestor path learns nothing it can
-   * keep about a node whose walk hit the cut, and re-walks that node along
-   * every path that reaches it — exponential over recursive value rules (linking
-   * jess's SCSS grammar cost ~290G instructions). This walk enters each node
-   * once per `Encoder`.
+   * is reachable from `root` — the writer census of `failureNeedsRollback`,
+   * entering each combinator once per `Encoder` (see `reachesMarked`).
    */
   private reachesSideWriter(root: Combinator<unknown>): boolean {
-    const memo = this.sideWriterMemo
-    const known = memo.get(root)
-    if (known !== undefined) return known
-    const order = new Map<Combinator<unknown>, number>()
-    const low: number[] = []
-    const found: boolean[] = []
-    const stack: Combinator<unknown>[] = []
-    const visit = (node: Combinator<unknown>): number => {
-      const at = low.length
-      order.set(node, at)
-      low.push(at)
-      found.push(false)
-      stack.push(node)
-      const next = this.sideWriterSuccessors(node)
-      if (next === true) found[at] = true
-      else {
-        for (const child of next) {
-          const hit = memo.get(child)
-          if (hit !== undefined) {
-            if (hit) found[at] = true
-            continue
-          }
-          const seen = order.get(child)
-          if (seen !== undefined) {
-            // Unmemoized but entered: still on the stack, so in this node's
-            // component. Its answer reaches the component's first node by the
-            // tree edges, not through here.
-            if (seen < low[at]!) low[at] = seen
-            continue
-          }
-          const k = visit(child)
-          if (low[k]! < low[at]!) low[at] = low[k]!
-          if (found[k]) found[at] = true
-        }
-      }
-      if (low[at] === at) {
-        const answer = found[at]!
-        let member: Combinator<unknown>
-        do {
-          member = stack.pop()!
-          memo.set(member, answer)
-        } while (member !== node)
-      }
-      return at
-    }
-    return found[visit(root)]!
+    return reachesMarked(root, node => this.sideWriterSuccessors(node), this.sideWriterMemo)
   }
 
   /** The census's edges out of `node`, or `true` when `node` is itself a writer. */
@@ -1268,7 +1221,7 @@ class Encoder {
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]!))
         }
         this.choiceRollbackMasks.set(head, rollbackMask)
-        if (arms.every(arm => !mayCommitFailure(arm, new Set(), rr))) {
+        if (arms.every(arm => !mayCommitFailure(arm, rr, this.commitFailureMemo))) {
           this.nonCommittingChoiceSites.add(head)
         }
         return head

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.55.1'
+export const PARSEMAN_VERSION = '0.55.3'