parseman 0.55.0 → 0.55.2

package/dist/analysis/commitment.d.ts

@@ -107,8 +107,33 @@ export declare function hasNodeDef(p: Combinator<unknown>, seen?: Set<Combinator
  * sites and neither of which `hasNodeDef` above walks.
  */
 export declare function hasDirectBuildDef(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>): boolean;
-/** True when `p` can report a committed failure through emitFallible's failure channel. */
-export declare function mayCommitFailure(p: Combinator<unknown>, seen?: Set<Combinator<unknown>>, resolve?: RefResolver): boolean;
+/**
+ * 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 declare function mayCommitFailure(p: Combinator<unknown>, resolve?: RefResolver, memo?: Map<Combinator<unknown>, boolean>): boolean;
+/**
+ * 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 declare function reachesMarked<T>(root: T, successors: (node: T) => readonly T[] | true, memo: Map<T, boolean>): boolean;
 /**
  * `hasDirectBuilders` / `isRecognitionOnly` for a rule map WITHOUT lowering it.
  *

package/dist/analysis/commitment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commitment.d.ts","sourceRoot":"","sources":["../../src/analysis/commitment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqCnG;AAkCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiC1G;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAAE,YAAY,UAAO,GAAG,OAAO,CAwGvI;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkDxG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAgCtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqC7G;AAED,2FAA2F;AAC3F,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAC1C,OAAO,CAAC,EAAE,WAAW,GACpB,OAAO,CA+CT;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,iBAAiB,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAwB5D"}
+{"version":3,"file":"commitment.d.ts","sourceRoot":"","sources":["../../src/analysis/commitment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqCnG;AAkCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAiC1G;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,EAAE,YAAY,UAAO,GAAG,OAAO,CAwGvI;AAED,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAkDxG;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAgCtG;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,CAAa,GAAG,OAAO,CAqC7G;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,EACtB,OAAO,CAAC,EAAE,WAAW,EACrB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,CAAa,GAClD,OAAO,CAET;AAsDD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,IAAI,EAAE,CAAC,EACP,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,CAAC,EAAE,GAAG,IAAI,EAC5C,IAAI,EAAE,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GACpB,OAAO,CAkDT;AAwCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,GAC7D;IAAE,iBAAiB,EAAE,OAAO,CAAC;IAAC,iBAAiB,EAAE,OAAO,CAAA;CAAE,CAwB5D"}

package/dist/analysis/diagnostics.js

@@ -3255,19 +3255,22 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
-function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
-  if (seen.has(p)) return false;
-  seen.add(p);
+function mayCommitFailure(p, resolve, memo = /* @__PURE__ */ new Map()) {
+  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve), memo);
+}
+var NO_EDGES = [];
+function commitFailureSuccessors(p, resolve) {
   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":
@@ -3276,31 +3279,77 @@ function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve) {
     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 !== void 0 && mayCommitFailure(d.recoverAt, seen, resolve) || d.stopAt !== void 0 && mayCommitFailure(d.stopAt, seen, resolve);
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
+        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
+      ];
     case "lazy": {
       try {
-        return mayCommitFailure(d.thunk(), seen, resolve);
+        return [d.thunk()];
       } catch {
         const name = p._ruleName;
         const target = name === void 0 ? void 0 : resolve?.(name);
-        return target === void 0 ? true : mayCommitFailure(target, seen, resolve);
+        return target === void 0 ? true : [target];
       }
     }
-    case "unknown":
-      return true;
     default:
-      return false;
+      return NO_EDGES;
   }
 }
+function reachesMarked(root, successors, memo) {
+  const known = memo.get(root);
+  if (known !== void 0) return known;
+  const order = /* @__PURE__ */ new Map();
+  const low = [];
+  const found = [];
+  const stack = [];
+  const visit = (node2) => {
+    const at = low.length;
+    order.set(node2, at);
+    low.push(at);
+    found.push(false);
+    stack.push(node2);
+    const next = successors(node2);
+    if (next === true) found[at] = true;
+    else {
+      for (const child of next) {
+        if (found[at]) break;
+        const hit = memo.get(child);
+        if (hit !== void 0) {
+          if (hit) found[at] = true;
+          continue;
+        }
+        const seen = order.get(child);
+        if (seen !== void 0) {
+          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;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node2);
+    }
+    return at;
+  };
+  return found[visit(root)];
+}
 
 // src/recovery/scan.ts
 function probeAt(sentinel, input, pos, ctx) {
@@ -6225,21 +6274,20 @@ var Encoder = class {
   nonCommittingChoiceSites = /* @__PURE__ */ new Set();
   failureRollbackCleanSites = /* @__PURE__ */ new Set();
   /**
-   * `hasSideWriter` memo for `failureNeedsRollback`, shared across every call
-   * for the lifetime of this `Encoder`. A cached entry is written only when
-   * `complete` is true, which means the answer is a path-independent fact
-   * about that combinator node — it does not depend on which root's traversal
-   * asked, only on the node's own reachable subgraph. Scoping the memo per call
-   * (as a local inside `failureNeedsRollback`) was correct but discarded that
-   * fact after every arm, so a grammar with many ordered-choice arms / optional
-   * / attempt sites re-walked the SAME shared rule graph from scratch for each
-   * site — O(sites × graph size) instead of O(graph size). Measured on the
-   * scss-parser grammar (composed CSS-base superset, the deepest/largest of the
-   * four grammars): 47-50s for one `compileRuleMap` with the per-call memo,
-   * versus the whole macro transform completing in under a second once this
-   * memo is hoisted here.
+   * `reachesSideWriter`'s answers, shared by every `failureNeedsRollback` call
+   * for the lifetime of this `Encoder`. Every entry is exact — it depends only on
+   * the node's own reachable subgraph, never on which root's walk asked — so each
+   * combinator is walked once per encode however many choice arms, optionals and
+   * attempt sites reach it.
    */
   sideWriterMemo = /* @__PURE__ */ new Map();
+  /**
+   * `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.
+   */
+  commitFailureMemo = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -6670,63 +6718,45 @@ var Encoder = class {
    * writer census covers the side sinks that proof deliberately does not model:
    * fields, recovered errors, and interpreted scanners. Strict assemblies do
    * not run repeat recovery, but these rows can still publish through a caller's
-   * context. Cycles are safe to stop: revisiting the same combinator cannot
-   * discover a writer the first traversal did not already reach.
+   * context.
    */
   failureNeedsRollback(p, autoNot) {
     const refName = p._ruleName;
     const winner = refName === void 0 ? void 0 : this.winners?.[refName];
     const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
-    const sideWriterMemo = this.sideWriterMemo;
-    const seen = /* @__PURE__ */ new Set();
-    const hasSideWriter = (current) => {
-      const cached = sideWriterMemo.get(current);
-      if (cached !== void 0) return { found: cached, complete: true };
-      if (seen.has(current)) return { found: false, complete: false };
-      seen.add(current);
-      const def = current._def;
-      let result;
-      switch (def.tag) {
-        case "field":
-        case "expect":
-        case "recover":
-        case "scanTo":
-        case "unknown":
-          result = { found: true, complete: true };
-          break;
-        case "lazy": {
-          const name = current._ruleName;
-          const resolvedWinner = name === void 0 ? void 0 : this.winners?.[name];
-          if (resolvedWinner !== void 0 && !winnerWrapsReference2(resolvedWinner, current)) {
-            result = hasSideWriter(resolvedWinner);
-            break;
-          }
-          try {
-            result = hasSideWriter(def.thunk());
-          } catch {
-            result = { found: true, complete: true };
-          }
-          break;
-        }
-        default: {
-          let complete = true;
-          result = { found: false, complete: true };
-          for (const child of childrenOf(def)) {
-            const childResult = hasSideWriter(child);
-            if (childResult.found) {
-              result = { found: true, complete: true };
-              break;
-            }
-            complete &&= childResult.complete;
-          }
-          if (!result.found) result = { found: false, complete };
+    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true) || this.reachesSideWriter(root) || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+  }
+  /**
+   * Whether a field, recovered error, interpreted scanner or unresolvable shape
+   * is reachable from `root` — the writer census of `failureNeedsRollback`,
+   * entering each combinator once per `Encoder` (see `reachesMarked`).
+   */
+  reachesSideWriter(root) {
+    return reachesMarked(root, (node2) => this.sideWriterSuccessors(node2), this.sideWriterMemo);
+  }
+  /** The census's edges out of `node`, or `true` when `node` is itself a writer. */
+  sideWriterSuccessors(node2) {
+    const def = node2._def;
+    switch (def.tag) {
+      case "field":
+      case "expect":
+      case "recover":
+      case "scanTo":
+      case "unknown":
+        return true;
+      case "lazy": {
+        const name = node2._ruleName;
+        const winner = name === void 0 ? void 0 : this.winners?.[name];
+        if (winner !== void 0 && !winnerWrapsReference2(winner, node2)) return [winner];
+        try {
+          return [def.thunk()];
+        } catch {
+          return true;
         }
       }
-      seen.delete(current);
-      if (result.found || result.complete) sideWriterMemo.set(current, result.found);
-      return result;
-    };
-    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true) || hasSideWriter(root).found || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+      default:
+        return childrenOf(def);
+    }
   }
   /** A first set becomes a char class string, or −1 for `any`. */
   charClass(fs) {
@@ -7057,7 +7087,7 @@ var Encoder = class {
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]));
         }
         this.choiceRollbackMasks.set(head, rollbackMask);
-        if (arms.every((arm) => !mayCommitFailure(arm, /* @__PURE__ */ new Set(), rr))) {
+        if (arms.every((arm) => !mayCommitFailure(arm, rr, this.commitFailureMemo))) {
           this.nonCommittingChoiceSites.add(head);
         }
         return head;