parseman 0.60.1 → 0.60.3

package/dist/plugin/index.js

@@ -6217,7 +6217,9 @@ function ownTableProgram(prog, resolved, caches = {}) {
       resolved,
       choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
       nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
-      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites,
+      choiceLogRollbackMasks: caches.choiceLogRollbackMasks ?? runtime?.choiceLogRollbackMasks,
+      failureLogRollbackSites: caches.failureLogRollbackSites ?? runtime?.failureLogRollbackSites
     }
   };
 }
@@ -6230,6 +6232,12 @@ function choiceCannotCommit(prog, ip) {
 function failureRollbackClean(prog, ip) {
   return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
 }
+function choiceLogRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceLogRollbackMasks?.get(ip) ?? 0;
+}
+function failureLogRollback(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureLogRollbackSites?.has(ip) === true;
+}
 var WIDE_CLASS_PREFIX_LO = 65535;
 var WIDE_CLASS_PREFIX_HI = 0;
 function validateClassRange(lo, hi) {
@@ -6492,7 +6500,7 @@ function mayFail(p, seen = /* @__PURE__ */ new Set()) {
       return true;
   }
 }
-function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
+function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true, throughNodes = false) {
   if (seen.has(p)) return false;
   seen.add(p);
   const d = p._def;
@@ -6517,17 +6525,26 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
       return false;
     // A run's prefixes are probed detached; only its body can capture.
     case "lines":
-      return mayLeavePartialCapture(d.body, seen, triviaActive);
-    // node() captures into its own private buffers and rolls them back on
-    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
+      return mayLeavePartialCapture(d.body, seen, triviaActive, throughNodes);
+    // node() captures its children into a frame of its own and drops it on
+    // failure. The trivia logs (`_triviaLog`, `_rootTriviaLog`) are not part of
+    // that frame: trivia its body scanned before failing stays recorded. With
+    // `throughNodes` (a program that installs trivia somewhere) a node leaves
+    // what its body leaves; without, it leaves nothing.
     case "node":
-      return false;
-    // choice/firstMatch already roll back each failed arm; on overall failure
-    // nothing committed remains.
+      return throughNodes && mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
+    // choice/firstMatch already roll back each failed arm's captures; on overall
+    // failure nothing committed remains. The trivia logs are the exception: a
+    // choice the table lowers as an exclusive dispatch runs its one selected arm
+    // with no mark of its own (`emit-assembly.ts`, `table.exclusive`), so the
+    // rows that arm's trivia scans recorded stay when it fails. With
+    // `throughNodes` a choice leaves what one of its arms leaves, unless
+    // `throughNodes` is the encoder's answer that this choice marks and restores
+    // each arm it enters.
     case "choice":
-      return false;
+      return throughNodes !== false && !(typeof throughNodes === "function" && throughNodes(p)) && d.parsers.some((arm) => mayLeavePartialCapture(arm, new Set(seen), triviaActive, throughNodes));
     case "dispatch":
-      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
+      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive, throughNodes) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive, throughNodes) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive, throughNodes) || capturesLeaf(d.otherwise, new Set(seen)) : false);
     case "attempt":
       return false;
     // optional never fails; many/oneOrMore only "fail" with zero captured items.
@@ -6569,7 +6586,7 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
         const part = parts[i];
         if (i > 0 && triviaActive) captured = true;
         if (captured && mayFail(part)) return true;
-        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
+        if (mayLeavePartialCapture(part, seen, triviaActive, throughNodes)) return true;
         if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
       }
       return false;
@@ -6581,12 +6598,12 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActiv
     case "expect":
     case "withCtx":
     case "grammar":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+      return mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
     case "recover":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+      return mayLeavePartialCapture(d.parser, seen, triviaActive, throughNodes);
     case "lazy": {
       try {
-        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
+        return mayLeavePartialCapture(d.thunk(), seen, triviaActive, throughNodes);
       } catch {
         return true;
       }
@@ -7589,6 +7606,32 @@ var Encoder = class {
   choiceRollbackMasks = /* @__PURE__ */ new Map();
   nonCommittingChoiceSites = /* @__PURE__ */ new Set();
   failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * THE TRIVIA LOGS A FAILED NODE LEAVES. A node drops its own capture frame when
+   * it fails, but the trivia its body recorded into `_triviaLog`/`_rootTriviaLog`
+   * is not part of that frame. So a child the census above counts as clean can
+   * still leave trivia rows when it reaches a node whose body can fail after a
+   * trivia scan (`mayLeavePartialCapture`'s `throughNodes`). These are the arms
+   * and sites that need only the two logs restored. A program with no trivia of
+   * its own records rows only under trivia its caller supplies, so its emitted
+   * assembly takes these marks only for such a parse (`RunCfg.inheritedTrivia`).
+   */
+  choiceLogRollbackMasks = /* @__PURE__ */ new Map();
+  failureLogRollbackSites = /* @__PURE__ */ new Set();
+  /**
+   * HOW EACH CHOICE WAS LOWERED, for the census above. A choice on the ordered
+   * path whose arms cannot commit a failure restores the logs after every arm
+   * it enters (its full mark, or its own two-log mark), so it leaves no rows.
+   * An exclusive dispatch runs its one arm with no mark, and an ordered choice
+   * returns a committed arm's failure before restoring, so either leaves what an
+   * arm leaves. A choice in neither set, or in both, is taken to leave rows. Both
+   * sets are complete only once every rule is encoded, so the trivia-log census
+   * runs then (`logCensus`).
+   */
+  restoringChoices = /* @__PURE__ */ new Set();
+  leakingChoices = /* @__PURE__ */ new Set();
+  logCensus = [];
+  restoresArms = (choice2) => this.restoringChoices.has(choice2) && !this.leakingChoices.has(choice2);
   /**
    * `reachesSideWriter`'s answers, shared by every `failureNeedsRollback` call
    * for the lifetime of this `Encoder`. Every entry is exact — it depends only on
@@ -8163,11 +8206,19 @@ var Encoder = class {
    * not run repeat recovery, but these rows can still publish through a caller's
    * context.
    */
-  failureNeedsRollback(p, autoNot) {
+  failureNeedsRollback(p, autoNot, throughNodes) {
     const refName = p._ruleName;
     const winner = refName === void 0 ? void 0 : this.winners?.[refName];
     const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
-    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true) || this.reachesSideWriter(root) || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true, throughNodes) || this.reachesSideWriter(root) || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+  }
+  /** The rollback census of an `optional()` or `attempt()` row at `ip` over `child`. */
+  censusTransaction(child, ip) {
+    if (this.failureNeedsRollback(child, void 0, false)) return;
+    this.failureRollbackCleanSites.add(ip);
+    this.logCensus.push(() => {
+      if (this.failureNeedsRollback(child, void 0, this.restoresArms)) this.failureLogRollbackSites.add(ip);
+    });
   }
   /**
    * Whether a field, recovered error, interpreted scanner or unresolvable shape
@@ -8789,13 +8840,11 @@ var Encoder = class {
         }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
+        const exclusive = dispatchIsExclusive(classes, this.cc);
         let rollbackMask = kids.length > 31 ? -1 : 0;
         if (rollbackMask === 0) {
           for (let i = 0; i < arms.length; i++) {
-            const src = order[i];
-            if (this.failureNeedsRollback(arms[i], d.autoNot[src])) {
-              rollbackMask |= 1 << i;
-            }
+            if (this.failureNeedsRollback(arms[i], d.autoNot[order[i]], false)) rollbackMask |= 1 << i;
           }
         }
         const head = this.emitHead(OP_CHOICE, 3 + 2 * kids.length);
@@ -8807,9 +8856,19 @@ 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, rr, this.commitFailureMemo))) {
-          this.nonCommittingChoiceSites.add(head);
+        if (rollbackMask !== -1) {
+          const full = rollbackMask;
+          this.logCensus.push(() => {
+            let logMask = 0;
+            for (let i = 0; i < arms.length; i++) {
+              if ((full & 1 << i) === 0 && this.failureNeedsRollback(arms[i], d.autoNot[order[i]], this.restoresArms)) logMask |= 1 << i;
+            }
+            if (logMask !== 0) this.choiceLogRollbackMasks.set(head, logMask);
+          });
         }
+        const nonCommitting = arms.every((arm) => !mayCommitFailure(arm, rr, this.commitFailureMemo));
+        if (nonCommitting) this.nonCommittingChoiceSites.add(head);
+        (!exclusive && nonCommitting ? this.restoringChoices : this.leakingChoices).add(p);
         return head;
       }
       case "many":
@@ -8845,7 +8904,7 @@ var Encoder = class {
       }
       case "optional": {
         const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
-        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
+        this.censusTransaction(d.parser, head);
         return head;
       }
       case "transform": {
@@ -9016,7 +9075,7 @@ var Encoder = class {
       // lowering was correct only for a choice arm.
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0);
-        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
+        this.censusTransaction(d.parser, inner);
         const fs3 = this.gateFirstSet(d.parser, d.guarded === true, false);
         if (fs3.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs3);
@@ -9180,6 +9239,7 @@ var Encoder = class {
   finish() {
     if (this.code.length === 0) this.emit(OP_EMPTY);
     this.collapseIndirection();
+    for (const census of this.logCensus) census();
     return ownTableProgram({
       code: this.code,
       k: this.k,
@@ -9204,6 +9264,8 @@ var Encoder = class {
     }, void 0, {
       choiceRollbackMasks: this.choiceRollbackMasks,
       failureRollbackCleanSites: this.failureRollbackCleanSites,
+      choiceLogRollbackMasks: this.choiceLogRollbackMasks,
+      failureLogRollbackSites: this.failureLogRollbackSites,
       nonCommittingChoiceSites: this.nonCommittingChoiceSites
     });
   }
@@ -11090,6 +11152,13 @@ if(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}e
   if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,undefined,undefined,${t}lg,${t}rt)`;
   return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "undefined"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
 }
+function emitLogMark(t) {
+  return `const ${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0,${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0`;
+}
+function emitLogRollback(t) {
+  return `{const g=ctx._triviaLog;if(g!==undefined)while(g.length>${t}lg)g.pop()}
+{const r=ctx._rootTriviaLog;if(r!==undefined)while(r.length>${t}rt)r.pop()}`;
+}
 function emitTerm(callee, dst, t, l, skip, miss) {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
@@ -11173,6 +11242,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, se
   const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
+  const LOGS = (prog.triviaSpecs?.length ?? 0) > 0 || cfg.inheritedTrivia === true;
   const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
@@ -11941,12 +12011,13 @@ return v
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
         const clean = !REC2 && failureRollbackClean(prog, ip);
+        const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
-${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${clean ? logs ? emitLogMark(p) : "" : emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 if(v!==FAIL)return v
-${clean ? "" : emitRollback(p, L.buf, L.raw, sinks)}
+${clean ? logs ? emitLogRollback(p) : "" : emitRollback(p, L.buf, L.raw, sinks)}
 ${code[ip + 2] === 1 ? "ctx._fc=false" : "if(ctx._fc===true)return FAIL"}
 ctx._fe=pos
 return FAIL
@@ -11972,6 +12043,7 @@ return FAIL
 ${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
 ${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
+ctx._fc=false
 ${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
@@ -11996,6 +12068,7 @@ return null
 ${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
 ${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
+ctx._fc=false
 ${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
@@ -12004,14 +12077,15 @@ return null
       case OP_OPT: {
         const child = link(code[ip + 1]);
         const clean = !REC2 && failureRollbackClean(prog, ip);
+        const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
-${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? logs ? emitLogMark(p) : "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
 if(ctx._fc===true)return FAIL
-${clean ? "" : emitRollback(p, L.buf, L.raw, sinks)}
+${clean ? logs ? emitLogRollback(p) : "" : emitRollback(p, L.buf, L.raw, sinks)}
 EC.e=pos
 return null
 }
@@ -12161,6 +12235,10 @@ return FAIL
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
           const rollbackMask = REC2 ? -1 : encodedRollbackMask;
           const hasRollback = rollbackMask !== 0;
+          const logMask = rollbackMask === -1 || !LOGS ? 0 : choiceLogRollbackMask(prog, ip);
+          const choiceMark = hasRollback ? emitMark(p, L.buf, L.raw, sinks) : "";
+          const armMark = (i) => !hasRollback && (logMask & 1 << i) !== 0 ? `${emitLogMark(p)}
+` : "";
           const startFailureExact = arms.every((_arm, i) => {
             const terminal = leadingScalarTerminal(code, code[base + i], 0, false);
             if (terminal < 0) return false;
@@ -12172,7 +12250,7 @@ return FAIL
             if (op2 === OP_LIT) return typeof spec === "string" && spec.length > 0;
             return op2 === OP_RX && spec instanceof RegExp && !regexCanMatchEmpty(spec.source);
           });
-          const rollbackFor = (i) => rollbackMask === -1 || (rollbackMask & 1 << i) !== 0 ? emitRollback(p, L.buf, L.raw, sinks) : "";
+          const rollbackFor = (i) => rollbackMask === -1 || (rollbackMask & 1 << i) !== 0 ? emitRollback(p, L.buf, L.raw, sinks) : (logMask & 1 << i) === 0 ? "" : hasRollback ? emitRollback(p, L.buf, L.raw, sinks) : emitLogRollback(p);
           if (choiceCannotCommit(prog, ip) && !startFailureExact) {
             const deepAt = Array.from({ length: n }, () => tmp());
             const deepFx = Array.from({ length: n }, () => tmp());
@@ -12198,7 +12276,7 @@ ${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}==
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate2}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
@@ -12217,7 +12295,7 @@ ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL`;
             return `${head}
 const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
-${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
+${choiceMark}
 ${deepAt.map((at, i) => `let ${at},${deepFx[i]}`).join("\n")}
 ${maskable ? `if(c<128){
 const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
@@ -12264,7 +12342,7 @@ if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.sequenc
 }`;
             return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if((bits&${1 << i})!==0${condition}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 ${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${i},prev,acc)
@@ -12295,7 +12373,7 @@ if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.token.e
 }${startFailureExact ? "" : `else if(best===pos)acc=_accSet(${expected[i]},acc)`}`;
             return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if((${gateRefs[i]}===null||classHas(${gateRefs[i]},c))${condition}){
-ctx._fc=false
+${armMark(i)}ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
@@ -12307,7 +12385,7 @@ ${rollbackFor(i)}
           }).join("\n");
           return `${head}
 const c=${directAsciiMask ? "input.charCodeAt(pos)" : "lead(input,pos)"}
-${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
+${choiceMark}
 let acc
 let best=pos
 ${maskable ? `if(c<128){
@@ -13387,7 +13465,7 @@ function clearOf(ranges, input, from, to) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.60.1";
+var PARSEMAN_VERSION = "0.60.3";
 
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
@@ -13659,11 +13737,11 @@ function linkMatcher(m) {
 }
 var NO_COVERAGE = (_id) => {
 };
-function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren = true) {
-  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe ? 16 : 0) | (hostReadsChildren ? 0 : 32);
+function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren = true, inheritedTrivia = false) {
+  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe ? 16 : 0) | (hostReadsChildren ? 0 : 32) | (inheritedTrivia ? 64 : 0);
 }
 function cfgKey(c) {
-  return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren);
+  return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren, c.inheritedTrivia);
 }
 function assertFactoryArity(pre) {
   if (pre.arity === EMITTED_PARAMS.length) return;
@@ -15038,6 +15116,7 @@ function assemble(t, prog, cfg) {
           const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          ctx._fc = false;
           if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             EC.e = pos;
@@ -15083,6 +15162,7 @@ function assemble(t, prog, cfg) {
           const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          ctx._fc = false;
           if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             ctx._fe = pos;
@@ -16941,7 +17021,7 @@ function assemble(t, prog, cfg) {
       if (emitted !== void 0) throw new ServedByBuild();
       if (prog.asm !== void 0) {
         throw new Unemittable(
-          `option set ${cfgKey(cfg)} (hostCst=${cfg.hostCst} trackLines=${cfg.trackLines} tolerant=${cfg.tolerant} coverage=${cfg.coverage} probe=${cfg.probe}), which this build did not pre-compile. The Function constructor is NOT used for an artifact that carries assemblies \u2014 see \`EmitOptions.assemblies\` to add this option set to the build`
+          `option set ${cfgKey(cfg)} (hostCst=${cfg.hostCst} trackLines=${cfg.trackLines} tolerant=${cfg.tolerant} coverage=${cfg.coverage} probe=${cfg.probe} inheritedTrivia=${cfg.inheritedTrivia === true}), which this build did not pre-compile. The Function constructor is NOT used for an artifact that carries assemblies \u2014 see \`EmitOptions.assemblies\` to add this option set to the build`
         );
       }
       if (!EMIT_ENABLED) throw new Unemittable("PM_TABLE_EMIT=0 (measurement toggle)");
@@ -17151,7 +17231,9 @@ function countSiteVisits(prog, parse2, fns = prog.fns) {
 var AssemblyCache = class {
   t;
   prog;
-  byCfg = Array.from({ length: 64 });
+  byCfg = Array.from({ length: 128 });
+  /** Whether this program installs no trivia of its own (`RunCfg.inheritedTrivia`). */
+  noOwnTrivia;
   /**
    * Monomorphic predicate inline cache. An assembly depends on the predicate
    * FUNCTION and the scalar cfg key, not on the host object that carries it, so
@@ -17164,6 +17246,7 @@ var AssemblyCache = class {
   constructor(prog, resolved = resolveTable(prog)) {
     this.prog = prog;
     this.t = resolved;
+    this.noOwnTrivia = prog.triviaSpecs === void 0 || prog.triviaSpecs.length === 0;
   }
   for(cfg) {
     const key = cfgKey(cfg);
@@ -17227,13 +17310,14 @@ var AssemblyCache = class {
     const tolerant = ctx._tolerant === true;
     const coverage = ctx._grammarCoverage !== void 0;
     const probe = ctx._probe !== void 0;
-    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren);
+    const inheritedTrivia = this.noOwnTrivia && ctx.trivia !== void 0;
+    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren, inheritedTrivia);
     let cache = this.byCfg;
     if (hostCaptureTrivia !== void 0) {
       if (this.hostPredicate === hostCaptureTrivia) {
         cache = this.hostAssemblies;
       } else {
-        cache = Array.from({ length: 64 });
+        cache = Array.from({ length: 128 });
         this.hostPredicate = hostCaptureTrivia;
         this.hostAssemblies = cache;
       }
@@ -17247,7 +17331,8 @@ var AssemblyCache = class {
       trackLines,
       tolerant,
       coverage,
-      probe
+      probe,
+      inheritedTrivia
     });
     cache[key] = made;
     return made;
@@ -22741,26 +22826,36 @@ function evalIR(ir, rulesImpl) {
 import { createHash } from "node:crypto";
 var TABLE_RUNTIME_SPECIFIER = "parseman/table";
 var CARRIED_SIDECAR_SUFFIX = ".parseman.json";
+function artifactDigest(code) {
+  const body = code.replace(/\n?\/\/# sourceMappingURL=[^\n]*\n?$/, "");
+  return createHash("sha256").update(body).digest("hex").slice(0, 32);
+}
 var _sidecarCache = /* @__PURE__ */ new Map();
 function readCarriedSidecar(artifact) {
   const file = artifact + CARRIED_SIDECAR_SUFFIX;
   let mtimeMs;
+  let artifactMtimeMs;
   try {
     mtimeMs = fs2.statSync(file).mtimeMs;
+    artifactMtimeMs = fs2.statSync(artifact).mtimeMs;
   } catch {
     return null;
   }
   const hit = _sidecarCache.get(file);
-  if (hit && hit.mtimeMs === mtimeMs) return hit.sidecar;
-  let sidecar = null;
+  if (hit && hit.mtimeMs === mtimeMs && hit.artifactMtimeMs === artifactMtimeMs) return hit.read;
+  let read = null;
   try {
     const parsed = JSON.parse(fs2.readFileSync(file, "utf8"));
     const exports = typeof parsed === "object" && parsed !== null ? parsed.exports : void 0;
-    if (typeof exports === "object" && exports !== null) sidecar = parsed;
+    if (typeof exports === "object" && exports !== null) {
+      const sidecar = parsed;
+      const stale = typeof sidecar.artifact === "string" && sidecar.artifact !== artifactDigest(fs2.readFileSync(artifact, "utf8"));
+      read = { sidecar, stale };
+    }
   } catch {
   }
-  _sidecarCache.set(file, { mtimeMs, sidecar });
-  return sidecar;
+  _sidecarCache.set(file, { mtimeMs, artifactMtimeMs, read });
+  return read;
 }
 var corpusCache = /* @__PURE__ */ new Map();
 function corpusTexts(profile) {
@@ -22880,58 +22975,95 @@ function parseModuleCached(filePath) {
   _moduleParseCache.set(filePath, { mtimeMs, parsed });
   return parsed;
 }
-function reexportSource(body, exported) {
+function exportOrigin(body, exported) {
+  const stars = [];
   for (const st of body) {
+    if (st.type === "ExportAllDeclaration") {
+      const from = st.source?.value;
+      if (st.exported == null && from !== void 0) stars.push(from);
+      continue;
+    }
     if (st.type !== "ExportNamedDeclaration") continue;
+    const decl = st.declaration;
+    if (decl != null) {
+      const ids = decl.type === "VariableDeclaration" ? (decl.declarations ?? []).map((d) => d.id?.name) : [decl.id?.name];
+      if (ids.includes(exported)) return "local";
+    }
     for (const sp of st.specifiers ?? []) {
       const exp = sp.exported;
       if ((exp?.name ?? exp?.value) !== exported) continue;
       const local = sp.local;
       const name = local?.name ?? local?.value;
-      if (name === void 0) return null;
+      if (name === void 0) return "local";
       const from = st.source?.value;
-      return from !== void 0 ? { source: from, imported: name } : extractImportBindings(body).get(name) ?? null;
-    }
-  }
-  return null;
-}
-async function followCarried(sinks, moduleId, name) {
-  for (let hop = 0; hop < 64; hop++) {
-    const own = sinks.get(moduleId)?.get(name);
-    if (own !== void 0) return own;
-    const code = this.getModuleInfo(moduleId)?.code;
-    if (!code) return void 0;
-    const parsed = parseSync5(moduleId, code);
-    if (parsed.errors.length > 0) return void 0;
-    const next = reexportSource(parsed.program.body, name);
-    if (next === null) return void 0;
-    const resolved = await this.resolve(next.source, moduleId);
+      if (from !== void 0) return { from, imported: name };
+      const imported = extractImportBindings(body).get(name);
+      return imported === void 0 ? "local" : { from: imported.source, imported: imported.imported };
+    }
+  }
+  return { stars };
+}
+async function followCarried(sinks, moduleId, name, depth = 0) {
+  if (depth > 64) return void 0;
+  const own = sinks.get(moduleId)?.get(name);
+  if (own !== void 0) return { items: own, recorder: moduleId };
+  const code = this.getModuleInfo(moduleId)?.code;
+  if (!code) return void 0;
+  const parsed = parseSync5(moduleId, code);
+  if (parsed.errors.length > 0) return void 0;
+  const origin = exportOrigin(parsed.program.body, name);
+  if (origin === "local") return null;
+  const follow = async (source, imported) => {
+    const resolved = await this.resolve(source, moduleId);
     if (resolved === null || resolved.external) return void 0;
-    moduleId = resolved.id;
-    name = next.imported;
+    return followCarried.call(this, sinks, resolved.id, imported, depth + 1);
+  };
+  if ("from" in origin) return follow(origin.from, origin.imported);
+  let found;
+  let unknown = false;
+  for (const source of origin.stars) {
+    const got = await follow(source, name);
+    if (got === void 0) unknown = true;
+    else if (got !== null) {
+      if (found !== void 0 && found.items !== got.items) return null;
+      found = got;
+    }
   }
-  return void 0;
+  return found ?? (unknown || origin.stars.length === 0 ? void 0 : null);
 }
 async function emitCarriedSidecars(sinks, bundle) {
-  const recorders = /* @__PURE__ */ new Map();
-  for (const [moduleId, sink] of sinks) for (const name of sink.keys()) (recorders.get(name) ?? recorders.set(name, []).get(name)).push(moduleId);
+  const write = async (rec) => {
+    const out = [];
+    for (const item of rec.items) {
+      if ("ir" in item) {
+        out.push(item);
+        continue;
+      }
+      const resolved = item.expanded === void 0 ? null : await this.resolve(item.from, rec.recorder);
+      if (resolved !== null && !resolved.external) out.push(...item.expanded);
+      else out.push({ from: item.from, name: item.name });
+    }
+    return out;
+  };
   for (const chunk of Object.values(bundle)) {
     if (chunk.type !== "chunk") continue;
     const exports = {};
     for (const name of chunk.exports ?? []) {
       const followed = chunk.facadeModuleId ? await followCarried.call(this, sinks, chunk.facadeModuleId, name) : void 0;
+      if (followed === null) continue;
       if (followed !== void 0) {
-        exports[name] = followed;
+        exports[name] = await write(followed);
         continue;
       }
-      const ids = recorders.get(name);
-      if (ids === void 0) continue;
-      const own = ids.filter((m) => chunk.moduleIds?.includes(m));
-      const moduleId = own.length === 1 ? own[0] : own.length === 0 && ids.length === 1 ? ids[0] : void 0;
-      if (moduleId !== void 0) exports[name] = sinks.get(moduleId).get(name);
+      const own = (chunk.moduleIds ?? []).filter((m) => sinks.get(m)?.has(name) === true);
+      if (own.length === 1) exports[name] = await write({ items: sinks.get(own[0]).get(name), recorder: own[0] });
     }
     if (Object.keys(exports).length === 0) continue;
-    const sidecar = { parseman: PARSEMAN_VERSION, exports };
+    const sidecar = {
+      parseman: PARSEMAN_VERSION,
+      ...chunk.code === void 0 ? {} : { artifact: artifactDigest(chunk.code) },
+      exports
+    };
     this.emitFile({ type: "asset", fileName: chunk.fileName + CARRIED_SIDECAR_SUFFIX, source: JSON.stringify(sidecar) });
   }
 }
@@ -22939,8 +23071,11 @@ var SIDECAR_FRAMEWORKS = /* @__PURE__ */ new Set(["rollup", "rolldown", "vite"])
 var plugin_default = createUnplugin((opts = {}, meta) => {
   const sinks = SIDECAR_FRAMEWORKS.has(meta.framework) ? /* @__PURE__ */ new Map() : void 0;
   const generateBundle = sinks === void 0 ? void 0 : {
-    generateBundle(_options, bundle) {
-      return emitCarriedSidecars.call(this, sinks, bundle);
+    generateBundle: {
+      order: "post",
+      handler(_options, bundle) {
+        return emitCarriedSidecars.call(this, sinks, bundle);
+      }
     }
   };
   return {
@@ -22954,16 +23089,14 @@ var plugin_default = createUnplugin((opts = {}, meta) => {
       return /\.[jt]sx?$/.test(id) && !id.includes("node_modules");
     },
     transform(code, id) {
+      sinks?.delete(id);
       if (!code.includes("parseman")) return null;
       if (!code.includes("macro")) return null;
       for (const file of opts.assemblyProfile?.files ?? []) this?.addWatchFile?.(file);
       const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
       const sink = sinks && /* @__PURE__ */ new Map();
       const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true, opts.assemblyProfile, opts.assemblyBudget, sink);
-      if (sinks && sink) {
-        if (sink.size > 0) sinks.set(id, sink);
-        else sinks.delete(id);
-      }
+      if (sinks && sink && sink.size > 0) sinks.set(id, sink);
       if (result?.warnings.length) {
         for (const w of result.warnings) {
           if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
@@ -23737,7 +23870,12 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
       unresolved.why ??= `${exportName} in ${file}: ${why}`;
       return null;
     };
-    const sidecarItems = module.source || local ? void 0 : readCarriedSidecar(file)?.exports[exportName];
+    const sidecarRead = module.source || local ? null : readCarriedSidecar(file);
+    if (sidecarRead?.stale === true) {
+      return fail(`${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX} was written for a different build of ${path2.basename(file)} (the artifact digest it records does not match). Rebuild the package so the two are written together`);
+    }
+    const sidecarExports = sidecarRead?.sidecar.exports;
+    const sidecarItems = sidecarExports !== void 0 && Object.hasOwn(sidecarExports, exportName) ? sidecarExports[exportName] : void 0;
     if (sidecarItems !== void 0) {
       const list = [];
       for (const item of sidecarItems) {
@@ -23760,7 +23898,20 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
     const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
     if (!literalRange) {
-      return initNode !== null && !module.source && mod.src.slice(initNode.start, initNode.end).includes("tableRules(") ? fail(`is a compiled grammar with no carried pieces \u2014 no inline literal, and no entry in ${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX}. Rebuild it with this parseman, and keep that file beside the artifact`) : null;
+      if (initNode !== null && !module.source && mod.src.slice(initNode.start, initNode.end).includes("tableRules(")) {
+        return fail(`is a compiled grammar with no carried pieces \u2014 no inline literal, and no entry in ${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX}. Rebuild it with this parseman, and keep that file beside the artifact`);
+      }
+      if (module.source || local) return null;
+      const origin = exportOrigin(mod.body, exportName);
+      const targets = origin === "local" ? [] : "from" in origin ? [{ source: origin.from, imported: origin.imported }] : origin.stars.map((source) => ({ source, imported: exportName }));
+      for (const target of targets) {
+        const sub = resolveGrammarModule(file, target.source);
+        if (sub === null || seen.has(sub.file)) continue;
+        const pieces = resolveModulePieces(sub, target.imported, new Set(seen).add(sub.file), unresolved);
+        if (pieces !== null) return pieces;
+      }
+      if (unresolved.why === void 0 && !mod.src.includes(TABLE_RUNTIME_SPECIFIER)) return null;
+      return fail(`is exported by a compiled grammar artifact, but no carried pieces could be found for it \u2014 no inline literal, no entry in ${path2.basename(file)}${CARRIED_SIDECAR_SUFFIX}, and no re-export of it that has either. Rebuild it with this parseman, and keep each chunk's .parseman.json beside it`);
     }
     const literal2 = mod.src.slice(literalRange.start, literalRange.end);
     const imports = extractImportBindings(mod.body);
@@ -23822,7 +23973,8 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
       const b = importBindings.get(it.__spreadLocal);
       if (b === void 0) return false;
       if (!b.source.startsWith(".") && !path2.isAbsolute(b.source)) {
-        out.push({ from: b.source, name: b.imported });
+        const expanded = importedPieces(it.__spreadLocal);
+        out.push({ from: b.source, name: b.imported, ...expanded === null ? {} : { expanded } });
         continue;
       }
       const pieces = importedPieces(it.__spreadLocal);
@@ -24567,6 +24719,7 @@ ${lines2.join("\n")}`);
 }
 export {
   CARRIED_SIDECAR_SUFFIX,
+  artifactDigest,
   plugin_default as default,
   transformMacro
 };