parseman 0.45.0 → 0.46.0

package/dist/index.js

@@ -2824,7 +2824,7 @@ function markUnusedValues(root) {
         return;
     }
   };
-  const resolveRoot = (c) => {
+  const resolveRoot2 = (c) => {
     const guard = /* @__PURE__ */ new Set();
     let cur = c;
     while (!guard.has(cur)) {
@@ -2839,7 +2839,7 @@ function markUnusedValues(root) {
     }
     return cur;
   };
-  visit(resolveRoot(root), true);
+  visit(resolveRoot2(root), true);
 }
 
 // src/combinators/grammar.ts
@@ -3443,7 +3443,8 @@ var RESOLVER_REASONS = {
   "unresolved-import": "its module could not be resolved or parsed",
   "not-found": "the name did not resolve to any binding",
   "computed": "it is a computed expression",
-  "foreign-source": "it is named inside an imported factory, whose offsets the entry-file resolver cannot index"
+  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
+  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
 };
 function unconfirmableReason(def, src) {
   const declared = def.buildArityUnresolved;
@@ -3972,7 +3973,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.45.0";
+var PARSEMAN_VERSION = "0.46.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -4027,14 +4028,28 @@ function firstSetToString(fs) {
   return fs.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
 var ruleNameOf2 = (p) => p._ruleName;
+var KEYWORD_REGEX_RE = /^\^?[@#.-]?[A-Za-z][\w-]*(\(\?![^)]*\))?\$?$/;
 var SUGGESTIONS = {
-  "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
-  "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
-  "nullable-prefix": "a leading optional/many lets a later, broad term start the arm. Split the empty case into its own arm, or gate on the prefix first char. A plain sepBy(item, sep) is ALSO nullable \u2014 pass { min: 1 } for a list that cannot be empty.",
-  "cross-artifact-ref": "parseman >=0.32.0 resolves a g.Foo ref first-set at fuse time; if still ANY the target rule is itself ungated \u2014 analyze it and give it a concrete non-nullable lead.",
-  "opaque-wrapper": "this wrapper (guard/withCtx/recover) contributes no first char; put a concrete leading terminal before it.",
-  "ref-cycle": "a recursive ref resolved to ANY; ensure the recursion has a concrete terminal lead on the base case."
+  "broad-recognizer": "This arm can begin with any character, so no single-character test can rule it out. The parser has to enter it \u2014 set up, try, and undo \u2014 at every position it reaches, instead of skipping it for free.\nTo fix: make the arm begin with a fixed character, word or keyword. If it is meant to be a catch-all that matches anything, leave it and add the choice to the accept list at the end.",
+  "leading-not": "This arm begins with a not(...) check, which matches nothing and so says nothing about which character the arm starts with. The parser then cannot rule the arm out and enters it everywhere.\nTo fix: put the term that actually consumes text first and keep not(...) after it as a trailing boundary. If you need to REQUIRE something ahead without consuming it, use peek(X) \u2014 it checks the same thing but still tells parseman that the arm starts with X.",
+  "nullable-prefix": "This arm begins with something optional \u2014 an optional(...) or a repeat that allows zero items \u2014 so the arm can also start with whatever comes AFTER it, and that is broad enough that no character rules the arm out.\nTo fix: give the optional part its own arm so each arm has a definite beginning, or require at least one item. A plain sepBy(item, sep) also matches nothing at all; pass { min: 1 } when the list must not be empty.",
+  "cross-artifact-ref": "This arm hands off to another rule, and that rule has the same problem \u2014 it can begin with any character \u2014 so the cost is inherited rather than caused here.\nTo fix: run this check on the rule it refers to and fix it there. One rule given a definite beginning fixes every choice that uses it.",
+  "opaque-wrapper": "This arm begins with a wrapper that only inspects parser state (a gate/withCtx/recover) and consumes no text, so it says nothing about which character the arm starts with.\nTo fix: put a term that actually matches text in front of the wrapper.",
+  "ref-cycle": "This arm refers back to itself through a cycle of rules, and parseman could not work out a definite first character for any of them.\nTo fix: make sure the base case of the recursion begins with a fixed character or keyword, so the cycle has somewhere definite to start."
 };
+function refineSuggestion(cause, arm) {
+  if (cause !== "broad-recognizer") return SUGGESTIONS[cause];
+  const lead = peelToLeading(arm);
+  const d = lead._def;
+  if (d.tag === "regex" && KEYWORD_REGEX_RE.test(d.source)) {
+    return `This arm matches the fixed word \`${d.source}\` with a regular expression, and parseman cannot always tell from a regular expression which character it starts with.
+To fix: write it as word('\u2026') or keywords([\u2026]) instead. They match exactly the same text and compile to the same character scan, but they also tell parseman the first character, which is what lets the parser skip this arm when it cannot match.`;
+  }
+  if (d.tag === "scanTo") {
+    return "This arm ends in a scanTo(...) catch-all, which reads forward until it finds something and so can begin at any character. The parser can never rule it out. That is usually exactly what you want from a fallback.\nTo fix: usually nothing. Add this choice to the accept list at the end so the check keeps flagging the choices that are real problems.";
+  }
+  return SUGGESTIONS[cause];
+}
 function classifyBroadArm(arm, resolve) {
   const seen = /* @__PURE__ */ new Set();
   const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
@@ -4150,7 +4165,6 @@ function peelToLeading(arm) {
   if (d.tag === "sequence" && d.parsers.length >= 1) return d.parsers[0];
   return cur;
 }
-var KEYWORD_REGEX_RE = /^\^?[@#.-]?[A-Za-z][\w-]*(\(\?![^)]*\))?\$?$/;
 function detectAntiPatterns(rule, arms) {
   const out = [];
   arms.forEach((arm, i) => {
@@ -4163,14 +4177,14 @@ function detectAntiPatterns(rule, arms) {
           kind: "double-not",
           rule,
           armIndex: i,
-          message: "not(not(...)) hand-rolls automatic first-char gating and MISCOMPILES among shared-first-char sibling arms (its first-set is ANY, poisoning dispatch). Prefer letting the arm lead with its consuming terminal; where a real positive lookahead IS needed, use peek(X) \u2014 zero-width like not(not(X)) but it CARRIES X's first-set, so the arm still dispatches."
+          message: 'not(not(X)) is a hand-written way of saying "X must come next, but do not consume it". parseman does that for you, and the hand-written form is worse than nothing here: because not(...) reveals no first character, the arm cannot be skipped, and among sibling arms that share a first character it can select the wrong one.\nTo fix: write peek(X). It checks the same thing without consuming, and it also tells parseman that the arm starts with whatever X starts with.'
         });
       } else {
         out.push({
           kind: "leading-not",
           rule,
           armIndex: i,
-          message: "a leading not(...) on a choice arm hand-rolls gating and poisons the choice first-set (not() is ANY). Reorder so a consuming terminal leads; keep not(...) as a TRAILING boundary only."
+          message: "This arm begins with not(...), which matches no text and so reveals no first character. The parser therefore cannot skip the arm and enters it at every position.\nTo fix: put the term that actually consumes text first, and keep not(...) after it as a trailing boundary check."
         });
       }
     }
@@ -4179,7 +4193,7 @@ function detectAntiPatterns(rule, arms) {
         kind: "keyword-regex",
         rule,
         armIndex: i,
-        message: `regex(/${ld.source}/) leads this arm but is a keyword \u2014 use word('\u2026', boundary) / keywords([\u2026]) for an EXACT resolvable first-set (they lower to the same charCodeAt scan).`
+        message: `This arm starts with the fixed word \`${ld.source}\` written as a regular expression. Writing it as word('\u2026') or keywords([\u2026]) matches exactly the same text and compiles to the same character scan, but also tells parseman the first character, which is what lets the parser skip the arm when it cannot match.`
       });
     }
   });
@@ -4221,7 +4235,7 @@ function analyzeGatingRules(ruleMap, opts) {
     const d = def;
     const rule = ruleNameOf2(p) ?? enclosingRule;
     if (d.tag === "choice") {
-      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
+      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule, arms: d.parsers });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
     }
     const rec = d;
@@ -4250,13 +4264,15 @@ function analyzeGatingRules(ruleMap, opts) {
   const seenInRule = /* @__PURE__ */ new Map();
   const accept = new Set(opts?.accept ?? []);
   const usedAccept = /* @__PURE__ */ new Set();
-  const choices = raw.map(({ g, rule }) => {
+  const choices = raw.map(({ g, rule, arms }) => {
     const n = seenInRule.get(rule) ?? 0;
     seenInRule.set(rule, n + 1);
     const id = (perRule.get(rule) ?? 1) === 1 ? rule : `${rule}#${n}`;
     const isAccepted = g.gates === "no" && accept.has(id);
     if (isAccepted) usedAccept.add(id);
-    return { ...g, id, accepted: isAccepted };
+    const out = { ...g, id, accepted: isAccepted };
+    Object.defineProperty(out, "arms", { value: arms, enumerable: false, writable: false });
+    return out;
   });
   const gated = choices.filter((c) => c.gates === "yes").length;
   const recoverable = choices.filter((c) => c.gates === "recoverable").length;
@@ -4283,7 +4299,14 @@ function analyzeChoice(p, d, rule, resolve) {
   const deep = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve));
   const anyArms = deep.map((fs, index) => ({ fs, index })).filter((x) => isAny(x.fs)).map(({ index }) => {
     const { cause, detail, unresolvedExternal } = classifyBroadArm(arms[index], resolve);
-    return { index, cause, detail, shallowAnyOnly: false, unresolvedExternal: unresolvedExternal === true, suggestion: SUGGESTIONS[cause] };
+    return {
+      index,
+      cause,
+      detail,
+      shallowAnyOnly: false,
+      unresolvedExternal: unresolvedExternal === true,
+      suggestion: refineSuggestion(cause, arms[index])
+    };
   });
   const overlaps = [];
   for (let i = 0; i < deep.length; i++)
@@ -4293,7 +4316,7 @@ function analyzeChoice(p, d, rule, resolve) {
           a: i,
           b: j,
           on: intersection(deep[i], deep[j]),
-          suggestion: "arms share a first char \u2014 left-factor. parseman auto-detects the sharedPrefix strategy for bare sequences (choice.ts); make the arms bare sequences with a common leading terminal, or restructure."
+          suggestion: "Two arms of this choice can begin with the same character, so the parser cannot tell from that character which one to try. It tries them in order and undoes the ones that do not match.\nTo fix: pull the shared beginning out in front of the choice so it is matched once \u2014 sequence(shared, choice(rest\u2026)) \u2014 instead of repeating it inside each arm. parseman recognises that shape automatically and turns it back into a single test."
         });
   let gates;
   if (d.disjoint) gates = "yes";
@@ -6105,15 +6128,15 @@ function parseStringShape(source) {
   if (source.length < 3 || source[source.length - 1] !== q) return null;
   const inner = source.slice(1, -1);
   const CLS = String.raw`\[\^((?:\\.|[^\]])+)\]`;
-  const ESC = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
+  const ESC2 = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
   let body;
   let esc;
-  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC}\\)\\*$`).exec(inner);
+  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC2}\\)\\*$`).exec(inner);
   if (m) {
     body = m[1];
     esc = m[2];
   } else {
-    m = new RegExp(`^\\((?:\\?:)?${ESC}\\|${CLS}\\)\\*$`).exec(inner);
+    m = new RegExp(`^\\((?:\\?:)?${ESC2}\\|${CLS}\\)\\*$`).exec(inner);
     if (m) {
       esc = m[1];
       body = m[2];
@@ -6123,8 +6146,8 @@ function parseStringShape(source) {
   const excluded = parseClassRanges(body);
   if (!excluded) return null;
   const qcp = q.codePointAt(0);
-  const inSet = (cp) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi);
-  if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
+  const inSet2 = (cp) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi);
+  if (!inSet2(qcp) || !inSet2(BACKSLASH)) return null;
   return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
 }
 function parseSeqParts(source) {
@@ -11583,7 +11606,7 @@ function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triv
   return host;
 }
 cstBuildHost._parsemanCstOutput = true;
-function fusedBody(pieces) {
+function fusedBody(pieces, hoist) {
   for (const p of pieces) {
     if (p.v === void 0) {
       throw new Error(
@@ -11623,8 +11646,7 @@ function fusedBody(pieces) {
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
   const reflection = mergeGrammarReflections([...winner].map(([k, p]) => p.nodeMeta.get(k) ?? { nodes: [] }));
   const { mode, elided } = hostModeOfPieces(pieces);
-  const rawBody = [
-    ...lines,
+  const tailSrc = [
     "const _map = {",
     wrapperEntries.join(",\n"),
     "}",
@@ -11640,6 +11662,7 @@ function fusedBody(pieces) {
     "}",
     "return _map"
   ].join("\n");
+  const rawBody = [...lines, tailSrc].join("\n");
   const ANY2 = { kind: "any" };
   const EMPTY3 = { kind: "empty" };
   const recipes = /* @__PURE__ */ new Map();
@@ -11680,7 +11703,7 @@ function fusedBody(pieces) {
     }
     if (!changed) break;
   }
-  const body = rawBody.replace(
+  const resolveFS = (src) => src.replace(
     // Rule name + code-point var are both JS identifiers (rule names are validated
     // at compile time — see assertRuleName in codegen), so an identifier class
     // matches every well-formed placeholder.
@@ -11691,6 +11714,7 @@ function fusedBody(pieces) {
       return `(${firstSetCond(codevar, fs)})`;
     }
   );
+  const body = hoist === void 0 ? resolveFS(rawBody) : [...hoist.claim(lines.map(resolveFS)), resolveFS(tailSrc)].join("\n");
   const env = {};
   for (const p of contributingPieces) {
     if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
@@ -11854,8 +11878,168 @@ function compose(items, opts) {
   if (coverageRules) Object.defineProperty(map, COMPOSED_COVERAGE_RULES, { value: coverageRules, enumerable: false });
   return map;
 }
-function composeLeaf(_items) {
-  throw new Error("composeLeaf(): requires Parseman macro lowering; runtime composition is forbidden");
+function composeLeaf(items) {
+  const pieces = items.flatMap(interpretedPieces);
+  let fused;
+  const map = {};
+  for (const name of ruleNamesOf(pieces)) {
+    Object.defineProperty(map, name, {
+      enumerable: true,
+      configurable: true,
+      get: () => (fused ??= fusePieces(pieces))[name]
+    });
+  }
+  Object.defineProperty(map, LEAF_COMPOSED, { value: true, enumerable: false });
+  Object.defineProperty(map, INTERPRETED_PIECES, {
+    value: pieces.filter((p) => p.plain).map((p) => p.entries),
+    enumerable: false
+  });
+  return map;
+}
+function isRefSlot(c) {
+  return c._def.tag === "lazy" && typeof c.define === "function";
+}
+var FUSE_ORIGINAL = /* @__PURE__ */ Symbol.for("parseman.interpretedFuseOriginal");
+var FUSE_TARGET = /* @__PURE__ */ Symbol.for("parseman.interpretedFuseTarget");
+var INTERPRETED_PIECES = /* @__PURE__ */ Symbol.for("parseman.interpretedPieces");
+function isInterpretedFuse(map) {
+  return Array.isArray(map[INTERPRETED_PIECES]);
+}
+function definitionOf(entry) {
+  if (isRefSlot(entry)) {
+    const original = entry[FUSE_ORIGINAL];
+    if (original !== void 0) return original ?? void 0;
+    try {
+      return entry._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  if (entry._def.tag === "lazy") {
+    try {
+      entry._def.thunk();
+    } catch {
+      return void 0;
+    }
+  }
+  return entry;
+}
+function repointRef(slot, target, name) {
+  const tagged = slot;
+  const bound = tagged[FUSE_TARGET];
+  const original = FUSE_ORIGINAL in tagged ? tagged[FUSE_ORIGINAL] : (() => {
+    try {
+      return slot._def.thunk();
+    } catch {
+      return null;
+    }
+  })();
+  if ((bound ?? original) === target) return;
+  if (bound !== void 0) {
+    throw new Error(
+      `fuseInterpreted: rule "${name}" is already bound by a DIFFERENT interpreted fusion of the same grammar piece. An interpreted fuse binds the shared placeholder objects in place, so two fusions cannot share a piece \u2014 build a fresh instance of the piece (call its rules() factory again, or import the module under a distinct specifier) for the second fusion.`
+    );
+  }
+  if (!(FUSE_ORIGINAL in tagged)) Object.defineProperty(slot, FUSE_ORIGINAL, { value: original, enumerable: false });
+  Object.defineProperty(slot, FUSE_TARGET, { value: target, enumerable: false });
+  slot._def.thunk = () => target;
+  slot.parse = (input, pos, ctx) => target.parse(input, pos, ctx);
+  const meta = slot._meta;
+  meta.firstSet = target._meta.firstSet;
+  meta.canMatchNewline = target._meta.canMatchNewline;
+  meta.isTrivia = target._meta.isTrivia;
+  if (target._meta.triviaKindLabels !== void 0) meta.triviaKindLabels = target._meta.triviaKindLabels;
+  else delete meta.triviaKindLabels;
+  if (target._meta.disjoint !== void 0) meta.disjoint = target._meta.disjoint;
+  else delete meta.disjoint;
+}
+function interpretedPieces(item) {
+  const fused = item[INTERPRETED_PIECES];
+  if (Array.isArray(fused)) return fused.map((entries) => ({ entries, plain: false }));
+  const carried = composedPiecesOf(item);
+  if (carried !== void 0) {
+    const { maps, opaque } = carriedRuleMapsDetailed(carried);
+    if (opaque.length > 0) {
+      throw new Error(
+        `fuseInterpreted: cannot interpret a composed grammar containing precompiled artifact(s) ${opaque.map((o) => `"${o.ns}" (${o.ruleNames.length} rules)`).join(", ")} \u2014 they carry compiled functions, not a combinator graph. Pass the source grammars (the same items you passed to compose()) instead.`
+      );
+    }
+    return maps.map((entries) => ({ entries, plain: false }));
+  }
+  if (item.ruleFns instanceof Map) {
+    throw new Error("fuseInterpreted: a precompiled linkable artifact has no combinator graph to interpret; pass the source grammar (a rules() map) instead");
+  }
+  return [{ entries: Object.entries(item), plain: true }];
+}
+function fuseInterpreted(items, opts) {
+  return fusePieces(items.flatMap(interpretedPieces), opts);
+}
+function ruleNamesOf(pieces) {
+  const names = /* @__PURE__ */ new Set();
+  for (const piece of pieces) {
+    for (const [name, value] of piece.entries) if (definitionOf(value) !== void 0) names.add(name);
+  }
+  return [...names];
+}
+function fusePieces(pieces, opts) {
+  let trivia2;
+  for (let i = pieces.length - 1; i >= 0 && trivia2 === void 0; i--) {
+    if (!pieces[i].plain) continue;
+    for (const [, rule] of pieces[i].entries) {
+      const t = rule._meta.grammarTrivia;
+      if (t) {
+        trivia2 = t;
+        break;
+      }
+    }
+  }
+  const winner = /* @__PURE__ */ new Map();
+  const entry = /* @__PURE__ */ new Map();
+  for (const piece of pieces) {
+    for (const [name, value] of piece.entries) {
+      const def = definitionOf(value);
+      if (def === void 0) continue;
+      winner.set(name, def);
+      entry.set(name, value);
+    }
+  }
+  const missing = /* @__PURE__ */ new Set();
+  for (const piece of pieces) {
+    for (const [name, value] of piece.entries) {
+      if (!isRefSlot(value)) continue;
+      const target = winner.get(name);
+      if (target === void 0) {
+        missing.add(name);
+        continue;
+      }
+      repointRef(value, target, name);
+    }
+  }
+  if (missing.size > 0) throw new Error(missingRuleMessage(pieces, missing));
+  const out = {};
+  for (const [name, value] of entry) {
+    out[name] = value;
+    const meta = value._meta;
+    if (trivia2 !== void 0 && !meta.isTrivia) meta.grammarTrivia = trivia2;
+    if (opts?.hostMode !== void 0 && !meta.isTrivia) {
+      if (opts.hostMode === "cst") meta.grammarHostMode = "cst";
+      else delete meta.grammarHostMode;
+    }
+  }
+  Object.defineProperty(out, INTERPRETED_PIECES, {
+    value: pieces.filter((p) => p.plain).map((p) => p.entries),
+    enumerable: false
+  });
+  return out;
+}
+function missingRuleMessage(pieces, missing) {
+  for (const piece of pieces) {
+    const deps = ruleDependencies(piece.entries.filter(([, v2]) => definitionOf(v2) !== void 0));
+    for (const [name, ds] of deps) {
+      for (const d of ds) if (missing.has(d)) return `fuseInterpreted: rule "${name}" references missing rule "${d}"`;
+    }
+  }
+  return `fuseInterpreted: missing rule(s) ${[...missing].map((n) => `"${n}"`).join(", ")}`;
 }
 
 // src/analysis/grammar.ts
@@ -11905,13 +12089,16 @@ function diagnoseGrammar(grammar, opts) {
   }
   return assemble(report, degradations);
 }
+function examinedNothing(d) {
+  return d.summary.totalChoices === 0 && d.summary.unanalysable > 0;
+}
 function formatGrammarDiagnosis(d) {
   const s = d.summary;
   const lines = [];
   lines.push(
-    d.ok ? `parseman: grammar OK \u2014 ${s.gated}/${s.totalChoices} choice(s) gate on first char${s.recoverable > 0 ? `, ${s.recoverable} recoverable` : ""}${s.accepted > 0 ? `, ${s.accepted} accepted` : ""}${s.deferred > 0 ? `, ${s.deferred} deferred to the fusing artifact` : ""}.` : `parseman: grammar NOT OK \u2014 ${blockingOf(d).length} blocking finding(s) over ${s.totalChoices} examined choice(s).`
+    examinedNothing(d) ? `parseman: COULD NOT ANALYSE \u2014 0 choice(s) examined; ${s.unanalysable} rule(s) unreadable. No verdict about this grammar is available, good or bad.` : d.ok ? `parseman: grammar OK \u2014 ${s.gated}/${s.totalChoices} choice(s) gate on first char${s.recoverable > 0 ? `, ${s.recoverable} recoverable` : ""}${s.accepted > 0 ? `, ${s.accepted} accepted` : ""}${s.deferred > 0 ? `, ${s.deferred} deferred to the fusing artifact` : ""}.` : `parseman: grammar NOT OK \u2014 ${blockingOf(d).length - s.unanalysable} blocking finding(s) over ${s.totalChoices} examined choice(s).`
   );
-  if (s.unanalysable > 0) {
+  if (s.unanalysable > 0 && !examinedNothing(d)) {
     lines.push(
       `  ${s.unanalysable} rule(s) UNANALYSABLE \u2014 THIS REPORT IS PARTIAL. An empty finding list below does NOT mean the grammar is clean.`
     );
@@ -12041,141 +12228,1081 @@ fix: ${o.suggestion}`)
   };
 }
 
-// src/combinators/gate.ts
-function gate(predicate) {
-  const meta = {
-    firstSet: { kind: "any" },
-    canMatchNewline: false,
-    isTrivia: false
-  };
-  return {
-    _tag: "guard",
-    _meta: meta,
-    _def: { tag: "guard", predicate },
-    parse(_input, pos, ctx) {
-      if (predicate(ctx.state))
-        return { ok: true, value: null, span: { start: pos, end: pos } };
-      return { ok: false, expected: ["guard"], span: { start: pos, end: pos } };
-    }
-  };
-}
-
-// src/combinators/completions.ts
-function completionsAt(target, input, offset, options = {}) {
-  const probe = { offset, best: null };
-  const ctx = { trackLines: false, _probe: probe, ...options.tolerant ? { _tolerant: true, _rec: REC } : {} };
-  const sliced = input.slice(0, offset);
-  const result = "parseWithContext" in target ? target.parseWithContext(sliced, ctx, 0) : target.parse(sliced, 0, ctx);
-  if (result.ok) return options.tolerant ? probe.best?.expected ?? [] : [];
-  const best = deeperFail(probe.best, result);
-  return best?.expected ?? [];
-}
-function deeperFail(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  return a.span.start >= b.span.start ? a : b;
+// src/functional/run.ts
+var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
+var REMOVED_RUN_RESULT_FIELDS = [
+  [
+    "triviaMap",
+    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
+  ],
+  [
+    "triviaLog",
+    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
+  ],
+  [
+    "triviaKindLabels",
+    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
+  ]
+];
+function guardRemovedFields(result) {
+  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
+    Object.defineProperty(result, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        throw new TypeError(
+          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
+        );
+      }
+    });
+  }
+  return result;
 }
-
-// src/cst/relative-spans.ts
-function relativize(node2, parentBase = 0) {
-  return {
-    start: node2.start - parentBase,
-    end: node2.end - parentBase,
-    children: node2.children.map((c) => relativize(c, node2.start))
-  };
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function triviaKindLabelsFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.triviaKindLabels;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
 }
-function absolutize(node2, parentBase = 0) {
-  const start = parentBase + node2.start;
-  return {
-    start,
-    end: parentBase + node2.end,
-    children: node2.children.map((c) => absolutize(c, start))
-  };
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
 }
-function absoluteSpanAt(root, path) {
-  let base = 0;
-  let node2 = root;
-  for (const idx of path) {
-    base += node2.start;
-    const child = node2.children[idx];
-    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join(".")}`);
-    node2 = child;
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
   }
-  return { start: base + node2.start, end: base + node2.end };
+  return index;
 }
-function relativizeCST(node2, parentBase = 0) {
-  const span = { start: node2.span.start - parentBase, end: node2.span.end - parentBase };
-  if (node2.children) {
-    const base = node2.span.start;
-    return { ...node2, span, children: node2.children.map((c) => relativizeCST(c, base)) };
+function runOnce(entry, input, options, phase, profileState) {
+  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
+    throw new TypeError(
+      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
+    );
   }
-  return { ...node2, span };
-}
-function absolutizeCST(node2, parentBase = 0) {
-  const start = parentBase + node2.span.start;
-  const span = { start, end: parentBase + node2.span.end };
-  if (node2.children) {
-    return { ...node2, span, children: node2.children.map((c) => absolutizeCST(c, start)) };
+  const rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
+  const errors = [];
+  const profile = profileState ?? (phase === void 0 ? void 0 : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 });
+  const skipGlobalSinks = phase === "recognizer" || phase === "capture";
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
+  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
   }
-  return { ...node2, span };
-}
-function absoluteSpanCST(root, path) {
-  let base = 0;
-  let node2 = root;
-  for (const idx of path) {
-    base += node2.span.start;
-    const child = node2.children?.[idx];
-    if (!child) throw new RangeError(`absoluteSpanCST: no child ${idx} on path ${path.join(".")}`);
-    node2 = child;
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
   }
-  return { start: base + node2.span.start, end: base + node2.span.end };
-}
-function shiftAbsolute(node2, at, delta) {
-  const s = node2.start >= at ? node2.start + delta : node2.start;
-  const e = node2.end >= at ? node2.end + delta : node2.end;
-  return {
-    start: s,
-    end: e,
-    children: node2.children.map((c) => shiftAbsolute(c, at, delta))
-  };
-}
-function applyEdit(root, at, delta, stats) {
-  return editNode(root, at, delta, 0, 0, stats);
-}
-function editNode(node2, at, delta, parentBase, parentShift, stats) {
-  const absStart = parentBase + node2.start;
-  const absEnd = parentBase + node2.end;
-  if (absEnd < at) return node2;
-  const startShifts = absStart >= at;
-  if (startShifts && parentShift === delta) return node2;
-  if (stats) stats.allocated++;
-  const newAbsStart = startShifts ? absStart + delta : absStart;
-  const newAbsEnd = absEnd + delta;
-  const newParentBase = parentBase + parentShift;
-  const newStart = newAbsStart - newParentBase;
-  const newEnd = newAbsEnd - newParentBase;
-  const ownShift = newAbsStart - absStart;
-  let changed = false;
-  const newChildren = [];
-  for (const c of node2.children) {
-    const nc = editNode(c, at, delta, absStart, ownShift, stats);
-    if (nc !== c) changed = true;
-    newChildren.push(nc);
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
   }
-  return {
-    start: newStart,
-    end: newEnd,
-    children: changed ? newChildren : node2.children
-  };
-}
-
-// src/functional/doc.ts
-function mkCtx(rawState, build, tolerant) {
-  const state = rawState ?? void 0;
-  return tolerant ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] } : { trackLines: false, state, build };
-}
-function asRuleFn(entry) {
-  return typeof entry === "function" ? entry : (input, pos, ctx) => entry.parse(input, pos, ctx);
+  const stamped = entry;
+  assertHostModeCompatible(
+    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
+    options.build,
+    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
+  );
+  const ctx = {
+    trackLines: false,
+    ...skipGlobalSinks ? { _pmProfile: profile } : {
+      ...captureRootTrivia ? {
+        _rootTriviaLog: selectedRootLog,
+        _rootTriviaKindIndex: selectedRootLabelIndex,
+        _rootTriviaStrictScopes: true
+      } : {},
+      _errors: errors,
+      ...profile === void 0 ? {} : { _pmProfile: profile }
+    },
+    build: options.build,
+    state: options.state,
+    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...triviaKindLabels ? { triviaKindLabels } : {} } : triviaKindLabels ? { triviaKindLabels } : {},
+    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
+    ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
+    ...options.tolerant ? { _tolerant: true, _rec: REC } : {},
+    ...options.instrumentation === void 0 ? {} : options.instrumentation
+  };
+  const r = invoke(entry, input, 0, ctx);
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = r.span?.end ?? 0;
+    if (options.trivia && pos < input.length) {
+      const t = invoke(options.trivia, input, pos, { trackLines: false });
+      if (t.ok && t.span.end > pos) pos = t.span.end;
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
+  }
+  return {
+    ok: r.ok,
+    value: r.ok ? r.value : void 0,
+    span: r.span ?? { start: 0, end: 0 },
+    expected: r.ok ? [] : r.expected ?? [],
+    errors,
+    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
+      rootTrivia: {
+        rows: selectedRootLog,
+        select: rootTriviaSelection,
+        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+      }
+    } : {},
+    unconsumedFrom
+  };
+}
+function run(entry, input, options = {}) {
+  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options));
+  throw new TypeError(
+    "run({ profile: true }) is unavailable: profiling counters are no longer compiled into parser artifacts, and the interpreter does not implement them yet. Profiling is moving to interpreted mode."
+  );
+}
+
+// src/analysis/choice-cost.ts
+var choiceSiteKey = (s) => s.path === "" ? s.rule : `${s.rule} \u203A ${s.path}`;
+function childrenOf5(d) {
+  switch (d.tag) {
+    case "sequence":
+    case "choice":
+      return d.parsers;
+    case "dispatch":
+      return [
+        d.selector,
+        ...d.cases.map((c) => c.parser),
+        ...d.otherwise === void 0 ? [] : [d.otherwise]
+      ];
+    case "skip":
+      return [d.main, d.skipped];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "recover":
+      return [d.parser, d.sentinel];
+    case "scanTo":
+      return [d.sentinel, ...d.skip];
+    case "grammar":
+      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "unknown":
+      return [];
+    default: {
+      const rec = d;
+      return rec.parser ? [rec.parser] : [];
+    }
+  }
+}
+var ruleNameOf5 = (p) => p._ruleName;
+function slotLabel(d, index) {
+  switch (d.tag) {
+    case "sequence":
+      return `seq[${index}]`;
+    case "choice":
+      return `choice[${index}]`;
+    case "dispatch":
+      return index === 0 ? "dispatch.selector" : `dispatch[${index - 1}]`;
+    case "skip":
+      return index === 0 ? "skip.main" : "skip.skipped";
+    case "sepBy":
+      return index === 0 ? "sepBy.item" : "sepBy.sep";
+    case "recover":
+      return index === 0 ? "recover.parser" : "recover.sentinel";
+    case "scanTo":
+      return index === 0 ? "scanTo.sentinel" : `scanTo.skip[${index - 1}]`;
+    case "grammar":
+      return index === 0 ? "grammar" : "grammar.trivia";
+    case "node":
+      return `node(${d.type ?? "anonymous"})`;
+    case "label":
+      return `label(${d.label})`;
+    case "field":
+      return `field(${d.name})`;
+    default:
+      return d.tag;
+  }
+}
+function resolveRoot(p) {
+  let cur = p;
+  for (let hop = 0; hop < 8; hop++) {
+    const d = cur._def;
+    if (d.tag !== "lazy") return { ok: true, p: cur };
+    let next;
+    try {
+      next = d.thunk();
+    } catch {
+      return { ok: false };
+    }
+    if (next === cur) return { ok: false };
+    cur = next;
+  }
+  return { ok: false };
+}
+function walkRules(ruleMap) {
+  assertAnalysable(ruleMap);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unresolvedRoots = [];
+  const visit = (p, rule, path) => {
+    if (seen.has(p)) return;
+    seen.add(p);
+    const d = p._def;
+    const own = ruleNameOf5(p);
+    const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path };
+    out.push({ p, d, site: here });
+    const kids = childrenOf5(d);
+    for (let i = 0; i < kids.length; i++) {
+      const seg = slotLabel(d, i);
+      visit(kids[i], here.rule, here.path === "" ? seg : `${here.path} \u203A ${seg}`);
+    }
+  };
+  for (const [name, rule] of ruleMap) {
+    const r = resolveRoot(rule);
+    if (!r.ok) {
+      unresolvedRoots.push(name);
+      continue;
+    }
+    visit(r.p, name, "");
+  }
+  unresolvedRoots.sort();
+  return { walked: out, unresolvedRoots };
+}
+function assertAnalysable(ruleMap) {
+  if (ruleMap.length === 0) {
+    throw new TypeError(
+      "choice-cost: the rule map is EMPTY. Analysing nothing and reporting no findings is indistinguishable from analysing a clean grammar, so this is refused rather than answered. Pass the rules() map (or the map given to compileRuleMap/compileLinkable)."
+    );
+  }
+  for (const [name, rule] of ruleMap) {
+    const def = rule?._def;
+    if (def !== null && typeof def === "object" && typeof def.tag === "string") continue;
+    throw new TypeError(
+      `choice-cost: rule '${name}' is not a combinator (no _def). This analysis walks the COMBINATOR TREE; the value returned by compose()/composeLeaf() is a fused artifact whose entries are parse functions. Pass the rules() map itself instead.`
+    );
+  }
+}
+function leadingTermOfArm2(arm) {
+  let d = arm._def;
+  for (; ; ) {
+    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label") {
+      d = d.parser._def;
+      continue;
+    }
+    break;
+  }
+  if (d.tag !== "sequence") {
+    return {
+      reason: "not-a-sequence",
+      detail: `arm is \`${d.tag}\`; only node/grammar/transform/label wrappers are peeled, because they are the ones that consume nothing before the sequence`
+    };
+  }
+  if (d.parsers.length < 2) {
+    return { reason: "sequence-shorter-than-2", detail: `sequence has ${d.parsers.length} term(s); nothing would remain after factoring` };
+  }
+  return { term: d.parsers[0] };
+}
+function leadingTermKey(term) {
+  const d = term._def;
+  if (d.tag === "literal") {
+    if (d.caseInsensitive) {
+      return { reason: "lead-case-insensitive-literal", detail: `literal ${JSON.stringify(d.value)} is case-insensitive; the matched text can differ from the literal's own value` };
+    }
+    return { key: `L:${JSON.stringify(d.value)}`, render: JSON.stringify(d.value) };
+  }
+  if (d.tag === "regex") {
+    return { key: `R:${JSON.stringify([d.source, d.flags])}`, render: `/${d.source}/${d.flags.replace(/[gy]/g, "")}` };
+  }
+  return {
+    reason: "lead-not-concrete-terminal",
+    detail: `leading term is \`${d.tag}\`${d.tag === "lazy" ? ` (ref${ruleNameOf5(term) === void 0 ? "" : ` to ${ruleNameOf5(term)}`})` : ""}; factoring through it would change the arm's value or capture shape`
+  };
+}
+function armLabel(arm) {
+  const name = ruleNameOf5(arm);
+  if (name !== void 0) return name;
+  let d = arm._def;
+  for (let hop = 0; hop < 8; hop++) {
+    if (d.tag === "node" && d.type !== void 0) return `node(${d.type})`;
+    if (d.tag === "label") return `label(${d.label})`;
+    if (d.tag === "field") return `field(${d.name})`;
+    if (d.tag === "literal") return JSON.stringify(d.value);
+    if (d.tag === "regex") return `/${d.source}/`;
+    if (d.tag === "keywords") return `keywords(${d.words.length})`;
+    if (d.tag === "sequence" || d.tag === "choice") {
+      const first = d.parsers[0];
+      if (first === void 0) return d.tag;
+      const inner = ruleNameOf5(first);
+      if (inner !== void 0) return `${d.tag}(${inner}, \u2026)`;
+      d = first._def;
+      continue;
+    }
+    const rec = d;
+    if (rec.parser === void 0) return d.tag;
+    d = rec.parser._def;
+  }
+  return arm._def.tag;
+}
+function analyzeChoiceInventory(ruleMap) {
+  const { walked, unresolvedRoots } = walkRules(ruleMap);
+  const entries = [];
+  for (const w of walked) {
+    if (w.d.tag !== "choice") continue;
+    const d = w.d;
+    const arity = d.parsers.length;
+    const strategy = d.strategy.tag;
+    const gated = d.gates.some((g) => g !== null);
+    const byKey = /* @__PURE__ */ new Map();
+    const armDeclines = [];
+    for (let i = 0; i < arity; i++) {
+      const lead = leadingTermOfArm2(d.parsers[i]);
+      if ("reason" in lead) {
+        armDeclines.push({ arm: i, reason: lead.reason, detail: lead.detail });
+        continue;
+      }
+      const keyed = leadingTermKey(lead.term);
+      if ("reason" in keyed) {
+        armDeclines.push({ arm: i, reason: keyed.reason, detail: keyed.detail });
+        continue;
+      }
+      const slot = byKey.get(keyed.key);
+      if (slot === void 0) byKey.set(keyed.key, { render: keyed.render, members: [i] });
+      else slot.members.push(i);
+    }
+    const groups = [...byKey.entries()].filter(([, v2]) => v2.members.length >= 2).map(([key, v2]) => ({ key, render: v2.render, members: v2.members })).sort((a, b) => b.members.length - a.members.length || (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+    const factored = strategy === "sharedPrefix";
+    let declineReason;
+    if (!factored) {
+      declineReason = arity < 2 ? "fewer-than-two-arms" : d.disjoint ? "disjoint-dispatch" : gated ? "gated-arms" : strategy !== "firstMatch" ? "strategy-preempted" : armDeclines.length > 0 ? "arms-not-factorable" : "leads-differ";
+    }
+    const inGroups = /* @__PURE__ */ new Set();
+    for (const g of groups) for (const m of g.members) inGroups.add(m);
+    entries.push({
+      site: w.site,
+      siteKey: choiceSiteKey(w.site),
+      arity,
+      strategy,
+      disjoint: d.disjoint,
+      gated,
+      groups,
+      armDeclines,
+      factored,
+      ...declineReason === void 0 ? {} : { declineReason },
+      unfactoredArms: factored ? 0 : inGroups.size
+    });
+  }
+  entries.sort((a, b) => a.siteKey < b.siteKey ? -1 : a.siteKey > b.siteKey ? 1 : 0);
+  const backlog = entries.filter((e) => !e.factored && e.groups.length > 0 && e.declineReason !== "disjoint-dispatch" && e.declineReason !== "strategy-preempted");
+  return {
+    schema: "parseman.choice-inventory/1",
+    rules: ruleMap.length,
+    choiceSites: entries.length,
+    factoredSites: entries.filter((e) => e.factored).length,
+    backlogSites: backlog.length,
+    backlogArms: backlog.reduce((n, e) => n + e.unfactoredArms, 0),
+    unresolvedRoots,
+    entries
+  };
+}
+function compiledFirstCharGate(p) {
+  const fs = p._meta.firstSet;
+  if (fs.kind !== "any" && !canMatchEmptyAtStart2(p)) return fs;
+  if (fs.kind !== "any" || canMatchEmptyAtStart2(p)) return null;
+  let deep;
+  try {
+    deep = firstSetOf(p);
+  } catch {
+    return null;
+  }
+  return deep.kind === "ranges" ? deep : null;
+}
+function canMatchEmptyAtStart2(p) {
+  const d = p._def;
+  switch (d.tag) {
+    case "regex":
+      return regexMatchesEmpty2(d.source, d.flags);
+    case "optional":
+    case "many":
+      return true;
+    case "transform":
+    case "label":
+    case "field":
+      return canMatchEmptyAtStart2(d.parser);
+    case "literal":
+      return d.value.length === 0;
+    default:
+      return false;
+  }
+}
+function regexMatchesEmpty2(source, flags) {
+  try {
+    return new RegExp(`^(?:${source})$`, flags.replace(/[gy]/g, "")).test("");
+  } catch {
+    return true;
+  }
+}
+function inSet(code, fs) {
+  if (fs.kind === "any") return true;
+  if (fs.kind === "empty") return false;
+  for (const r of fs.ranges) if (code >= r.lo && code <= r.hi) return true;
+  return false;
+}
+var TERMINAL_TAGS = /* @__PURE__ */ new Set(["literal", "regex", "keywords", "scanTo"]);
+var INSTRUMENTABLE = /* @__PURE__ */ new Set(["firstMatch", "sharedPrefix"]);
+function profileWastedWork(opts) {
+  const { rules: rules2, corpus } = opts;
+  const { walked, unresolvedRoots } = walkRules(rules2);
+  const entryParser = typeof opts.entry === "string" ? rules2.find(([n]) => n === opts.entry)?.[1] : opts.entry;
+  if (entryParser === void 0) {
+    throw new TypeError(
+      `choice-cost: entry rule '${String(opts.entry)}' is not in the rule map (have: ${rules2.map(([n]) => n).slice(0, 12).join(", ")}${rules2.length > 12 ? ", \u2026" : ""}).`
+    );
+  }
+  if (corpus.length === 0) {
+    throw new TypeError("choice-cost: the corpus is EMPTY. A profile over no input measures nothing; refusing to report zero wasted bytes as a result.");
+  }
+  for (const f of corpus) {
+    if (f.text.length === 0) throw new TypeError(`choice-cost: corpus entry '${f.id}' is EMPTY.`);
+  }
+  let highWater = 0;
+  const armRecords = [];
+  const siteTotals = /* @__PURE__ */ new Map();
+  const restore = [];
+  const undoAll = () => {
+    for (let i = restore.length - 1; i >= 0; i--) restore[i]();
+  };
+  let instrumentedSites = 0;
+  let uninstrumentableSites = 0;
+  try {
+    for (const w of walked) {
+      if (w.d.tag !== "choice") continue;
+      const siteKey = choiceSiteKey(w.site);
+      const strategy = w.d.strategy.tag;
+      const canInstrument = INSTRUMENTABLE.has(strategy) && !w.d.disjoint;
+      const rec = {
+        siteKey,
+        site: w.site,
+        strategy,
+        arity: w.d.parsers.length,
+        instrumented: canInstrument,
+        attempts: 0,
+        failures: 0,
+        wastedBytes: 0,
+        gatedAttempts: 0,
+        gatedFailures: 0,
+        gatedWastedBytes: 0
+      };
+      if (siteTotals.has(siteKey)) {
+        uninstrumentableSites++;
+        continue;
+      }
+      siteTotals.set(siteKey, rec);
+      if (!canInstrument) {
+        uninstrumentableSites++;
+        continue;
+      }
+      instrumentedSites++;
+      const slots = w.d.parsers;
+      for (let i = 0; i < slots.length; i++) {
+        const original = slots[i];
+        const gate2 = compiledFirstCharGate(original);
+        const armRec = {
+          site: w.site,
+          siteKey,
+          arm: i,
+          label: armLabel(original),
+          gate: gate2,
+          attempts: 0,
+          failures: 0,
+          wastedBytes: 0,
+          gatedAttempts: 0,
+          gatedFailures: 0,
+          gatedWastedBytes: 0
+        };
+        armRecords.push(armRec);
+        const wrapper = {
+          _tag: original._tag,
+          _meta: original._meta,
+          _def: original._def,
+          parse(input, pos, ctx) {
+            const code = pos < input.length ? input.codePointAt(pos) ?? -1 : -1;
+            const entered = gate2 === null || code >= 0 && inSet(code, gate2);
+            const saved = highWater;
+            highWater = pos;
+            const r = original.parse(input, pos, ctx);
+            const reach = highWater;
+            highWater = saved > reach ? saved : reach;
+            armRec.attempts++;
+            rec.attempts++;
+            if (entered) {
+              armRec.gatedAttempts++;
+              rec.gatedAttempts++;
+            }
+            if (!r.ok) {
+              armRec.failures++;
+              rec.failures++;
+              if (entered) {
+                armRec.gatedFailures++;
+                rec.gatedFailures++;
+              }
+              const wasted = reach - pos;
+              if (wasted > 0) {
+                armRec.wastedBytes += wasted;
+                rec.wastedBytes += wasted;
+                if (entered) {
+                  armRec.gatedWastedBytes += wasted;
+                  rec.gatedWastedBytes += wasted;
+                }
+              }
+            }
+            return r;
+          }
+        };
+        const rn = ruleNameOf5(original);
+        if (rn !== void 0) wrapper._ruleName = rn;
+        slots[i] = wrapper;
+        restore.push(() => {
+          slots[i] = original;
+        });
+      }
+    }
+    if (instrumentedSites === 0) {
+      throw new TypeError(
+        "choice-cost: the grammar contains NO instrumentable choice site (no `firstMatch` or `sharedPrefix` choice). A wasted-work profile over it would report zero for a reason that has nothing to do with the grammar being efficient, so it is refused."
+      );
+    }
+    for (const w of walked) {
+      if (!TERMINAL_TAGS.has(w.d.tag)) continue;
+      const p = w.p;
+      const original = p.parse;
+      p.parse = ((input, pos, ctx) => {
+        if (pos > highWater) highWater = pos;
+        return original.call(w.p, input, pos, ctx);
+      });
+      restore.push(() => {
+        p.parse = original;
+      });
+    }
+  } catch (e) {
+    undoAll();
+    throw e;
+  }
+  let parsedOk = 0;
+  let parsedFailed = 0;
+  let corpusBytes = 0;
+  try {
+    const runner = opts.runner ?? ((e, input, options) => run(e, input, options));
+    for (const f of corpus) {
+      corpusBytes += f.text.length;
+      highWater = 0;
+      const r = runner(entryParser, f.text, opts.runOptions ?? {});
+      if (r.ok) parsedOk++;
+      else parsedFailed++;
+    }
+  } finally {
+    undoAll();
+  }
+  const arms = armRecords.filter((a) => a.attempts > 0).map((a) => ({
+    siteKey: a.siteKey,
+    site: a.site,
+    arm: a.arm,
+    label: a.label,
+    attempts: a.attempts,
+    failures: a.failures,
+    wastedBytes: a.wastedBytes,
+    firstCharGated: a.gate !== null,
+    gatedAttempts: a.gatedAttempts,
+    gatedFailures: a.gatedFailures,
+    gatedWastedBytes: a.gatedWastedBytes
+  })).sort((x, y) => y.gatedWastedBytes - x.gatedWastedBytes || y.wastedBytes - x.wastedBytes || (x.siteKey < y.siteKey ? -1 : x.siteKey > y.siteKey ? 1 : 0) || x.arm - y.arm);
+  const sites = [...siteTotals.values()].sort((x, y) => y.gatedWastedBytes - x.gatedWastedBytes || y.wastedBytes - x.wastedBytes || (x.siteKey < y.siteKey ? -1 : x.siteKey > y.siteKey ? 1 : 0));
+  const minAttempts = opts.inversionMinAttempts ?? 4;
+  const inversions = arms.filter((a) => a.gatedAttempts >= minAttempts && a.gatedFailures === a.gatedAttempts && arms.some((b) => b.siteKey === a.siteKey && b.arm > a.arm && b.gatedAttempts > b.gatedFailures)).sort((x, y) => y.gatedAttempts - x.gatedAttempts || y.gatedWastedBytes - x.gatedWastedBytes || (x.siteKey < y.siteKey ? -1 : x.siteKey > y.siteKey ? 1 : 0) || x.arm - y.arm);
+  return {
+    schema: "parseman.wasted-work/1",
+    corpusFiles: corpus.length,
+    corpusBytes,
+    parsedOk,
+    parsedFailed,
+    instrumentedSites,
+    uninstrumentableSites,
+    unresolvedRoots,
+    totalWastedBytes: sites.reduce((n, s) => n + s.wastedBytes, 0),
+    totalGatedWastedBytes: sites.reduce((n, s) => n + s.gatedWastedBytes, 0),
+    arms,
+    inversions,
+    sites
+  };
+}
+
+// src/analysis/choice-cost-render.ts
+function groupDigits(n) {
+  const s = String(Math.trunc(Math.abs(n)));
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    if (i > 0 && (s.length - i) % 3 === 0) out += ",";
+    out += s[i];
+  }
+  return (n < 0 ? "-" : "") + out;
+}
+function bytes(n) {
+  if (n < 1024) return `${groupDigits(n)} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} kB`;
+  return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+var ESC = "\x1B";
+var ANSI = {
+  dim: `${ESC}[2m`,
+  bold: `${ESC}[1m`,
+  red: `${ESC}[31m`,
+  yellow: `${ESC}[33m`,
+  cyan: `${ESC}[36m`,
+  reset: `${ESC}[0m`
+};
+var paint = (on) => (code, s) => on ? `${ANSI[code]}${s}${ANSI.reset}` : s;
+var pad = (s, w) => s.length >= w ? s : s + " ".repeat(w - s.length);
+var padStart = (s, w) => s.length >= w ? s : " ".repeat(w - s.length) + s;
+var ARM_DECLINE_LINE = {
+  "not-a-sequence": "arm is not a sequence, so there is no leading term to lift out",
+  "sequence-shorter-than-2": "arm is a one-term sequence; lifting its only term would leave an empty arm",
+  "lead-case-insensitive-literal": "leading literal is case-insensitive, so the matched text can differ from the literal \u2014 a lifted prefix would carry the wrong string",
+  "lead-not-concrete-terminal": "leading term is not a bare literal or regex; lifting it would change the arm\u2019s value or capture shape"
+};
+var SITE_DECLINE_LINE = {
+  "disjoint-dispatch": "first-char dispatch already selects one arm \u2014 nothing is re-scanned",
+  "gated-arms": "an arm carries a runtime gate; per-arm predicates are incompatible with factoring",
+  "strategy-preempted": "a stronger non-backtracking strategy already applies",
+  "fewer-than-two-arms": "fewer than two arms",
+  "arms-not-factorable": "at least one arm cannot contribute a leading term (see below)",
+  "leads-differ": "the arms do not all begin with the same term"
+};
+function leftFactorPreview(e) {
+  if (e.factored) return null;
+  if (e.groups.length !== 1) return null;
+  const g = e.groups[0];
+  if (g.members.length !== e.arity) return null;
+  const tails = g.members.map((i) => `sequence(\u2026arm[${i}] tail\u2026)`).join(",\n    ");
+  return `sequence(
+  ${g.render === "" ? "<prefix>" : g.render.startsWith("/") ? `regex(${g.render})` : `literal(${g.render})`},
+  choice(
+    ${tails},
+  ),
+)`;
+}
+function renderChoiceInventory(r, opts = {}) {
+  const c = paint(opts.color === true);
+  const limit = opts.limit ?? 20;
+  const out = [];
+  out.push(c("bold", "shared-prefix inventory"));
+  out.push(c("dim", "  Static grammar shape only. A site listed here may already cost nothing at runtime:"));
+  out.push(c("dim", "  compiled output gates each arm on its first character. Rank with profileWastedWork()."));
+  out.push(`  ${groupDigits(r.rules)} rules, ${groupDigits(r.choiceSites)} choice sites`);
+  out.push(`  ${groupDigits(r.factoredSites)} left-factored by the compiler`);
+  out.push(`  ${groupDigits(r.backlogSites)} sites where alternatives share a leading term and the compiler DECLINED (${groupDigits(r.backlogArms)} arms)`);
+  const backlog = r.entries.filter((e) => !e.factored && e.groups.length > 0 && e.declineReason !== "disjoint-dispatch" && e.declineReason !== "strategy-preempted").sort((a, b) => b.unfactoredArms - a.unfactoredArms || (a.siteKey < b.siteKey ? -1 : 1));
+  if (backlog.length === 0) {
+    out.push("");
+    out.push("  no declined shared prefixes.");
+    return out.join("\n");
+  }
+  out.push("");
+  for (const e of backlog.slice(0, limit)) {
+    out.push(`  ${c("cyan", e.siteKey)}  ${c("dim", `${e.arity} arms \xB7 ${e.strategy}`)}`);
+    for (const g of e.groups) {
+      out.push(`    arms ${g.members.join(", ")} all begin with ${c("bold", g.render)}`);
+    }
+    out.push(`    ${c("yellow", "declined")}: ${SITE_DECLINE_LINE[e.declineReason]}`);
+    for (const a of e.armDeclines) {
+      out.push(`      arm[${a.arm}] \u2014 ${ARM_DECLINE_LINE[a.reason]}`);
+    }
+    const fix = leftFactorPreview(e);
+    if (fix !== null) {
+      out.push(`    ${c("dim", "candidate rewrite (preview \u2014 not applied, not yet digest-verified):")}`);
+      for (const line of fix.split("\n")) out.push(`      ${line}`);
+    }
+    out.push("");
+  }
+  if (backlog.length > limit) out.push(`  \u2026 and ${groupDigits(backlog.length - limit)} more (the report holds all of them)`);
+  return out.join("\n");
+}
+function renderWastedWork(r, opts = {}) {
+  const c = paint(opts.color === true);
+  const limit = opts.limit ?? 20;
+  const out = [];
+  const removed = r.arms.reduce((n, a) => n + (a.attempts - a.gatedAttempts), 0);
+  const totalAttempts = r.arms.reduce((n, a) => n + a.attempts, 0);
+  out.push(c("bold", "wasted work \u2014 input bytes re-scanned after a failed alternative"));
+  out.push(...interpretedBanner(c, removed, totalAttempts));
+  out.push(`  corpus: ${groupDigits(r.corpusFiles)} files, ${bytes(r.corpusBytes)} (${groupDigits(r.parsedOk)} parsed, ${groupDigits(r.parsedFailed)} failed)`);
+  out.push(`  sites:  ${groupDigits(r.instrumentedSites)} instrumented, ${groupDigits(r.uninstrumentableSites)} not instrumentable`);
+  if (r.unresolvedRoots.length > 0) {
+    out.push(`  ${c("yellow", "PARTIAL")}: ${groupDigits(r.unresolvedRoots.length)} rule(s) could not be resolved and were NOT walked \u2014 the total below is a lower bound`);
+  }
+  out.push(`  total:  ${c("bold", bytes(r.totalGatedWastedBytes))} re-scanned` + (r.corpusBytes > 0 ? ` \u2014 ${(r.totalGatedWastedBytes / r.corpusBytes).toFixed(2)}x the corpus` : "") + (r.totalWastedBytes === r.totalGatedWastedBytes ? "" : `  (interpreted: ${bytes(r.totalWastedBytes)})`));
+  const ranked = r.sites.filter((s) => s.gatedWastedBytes > 0 || s.wastedBytes > 0);
+  if (ranked.length === 0) {
+    out.push("");
+    out.push("  no alternative failed on this corpus.");
+    return out.join("\n");
+  }
+  out.push("");
+  out.push(c("dim", '  per arm: "entered" counts what the COMPILED parser reaches; the parenthesised'));
+  out.push(c("dim", "  number is the interpreted count, shown only where the first-char gate differs."));
+  out.push("");
+  const w = Math.min(52, Math.max(...ranked.slice(0, limit).map((s) => s.siteKey.length)));
+  for (const s of ranked.slice(0, limit)) {
+    const share = r.totalGatedWastedBytes > 0 ? ` ${padStart((100 * s.gatedWastedBytes / r.totalGatedWastedBytes).toFixed(1) + "%", 7)}` : "";
+    out.push(`  ${c("cyan", pad(s.siteKey.slice(0, w), w))} ${padStart(bytes(s.gatedWastedBytes), 10)}${c("dim", share)}`);
+    const arms = r.arms.filter((a) => a.siteKey === s.siteKey).sort((a, b) => a.arm - b.arm);
+    for (const a of arms) {
+      const entered = a.gatedAttempts === a.attempts ? groupDigits(a.attempts) : `${groupDigits(a.gatedAttempts)} (${groupDigits(a.attempts)} interp)`;
+      const verdict = a.gatedAttempts === 0 ? { text: "never entered when compiled", color: "dim" } : a.gatedFailures === a.gatedAttempts ? { text: `failed ALL ${entered}`, color: "red" } : a.gatedFailures === 0 ? { text: `matched ${entered}`, color: "dim" } : { text: `failed ${groupDigits(a.gatedFailures)} / ${entered}`, color: null };
+      const cell = verdict.color === null ? pad(verdict.text, 34) : c(verdict.color, pad(verdict.text, 34));
+      out.push(`    ${padStart(String(a.arm), 2)}  ${pad(a.label.slice(0, 30), 30)} ${cell} ${a.gatedWastedBytes > 0 ? padStart(bytes(a.gatedWastedBytes), 10) : ""}`);
+    }
+    out.push("");
+  }
+  if (ranked.length > limit) out.push(`  \u2026 and ${groupDigits(ranked.length - limit)} more sites (the report holds all of them)`);
+  if (r.inversions.length > 0) {
+    out.push(c("bold", "  ordering inversions \u2014 arm failed EVERY compiled entry while a later arm matched"));
+    out.push(c("dim", "  ranked by entries, not bytes: an arm can fail 100% of the time and re-scan nothing."));
+    for (const a of r.inversions.slice(0, limit)) {
+      out.push(`    ${c("cyan", pad(a.siteKey.slice(0, w), w))} arm ${padStart(String(a.arm), 2)}  ${pad(a.label.slice(0, 26), 26)} ${padStart(groupDigits(a.gatedAttempts), 8)} entries  ${a.gatedWastedBytes > 0 ? padStart(bytes(a.gatedWastedBytes), 10) : padStart("0 B", 10)}`);
+    }
+    if (r.inversions.length > limit) out.push(`    \u2026 and ${groupDigits(r.inversions.length - limit)} more`);
+  }
+  return out.join("\n");
+}
+function interpretedBanner(c, removed, total) {
+  const share = total > 0 ? ` \u2014 ${(100 * removed / total).toFixed(0)}% of interpreted arm entries` : "";
+  return [
+    c("yellow", "  MEASURED IN THE INTERPRETER. Compiled output gates each arm on its first"),
+    c("yellow", `  character; ${groupDigits(removed)} entries below never happen in the shipped parser${share}.`),
+    c("dim", "  Counts shown are the modelled COMPILED ones. Byte totals are unaffected by the"),
+    c("dim", "  gate (a gated-out arm consumes nothing); entry counts and failure RATES are not.")
+  ];
+}
+
+// src/analysis/choice-cost-gate.ts
+var KIND_ORDER = [
+  "invalid-baseline",
+  "unmeasurable",
+  "ceiling",
+  "drift",
+  "shrank",
+  "inversion",
+  "unbaselined",
+  "stale"
+];
+var pct = (actual, base) => base === 0 ? actual === 0 ? 0 : Infinity : (actual / base - 1) * 100;
+function checkWastedWork(reports, baseline, policy = {}) {
+  const breaches = [];
+  const tolerance = policy.driftTolerancePct ?? 1;
+  const add = (kind, key, detail) => {
+    breaches.push({ kind, key, detail });
+  };
+  const finish = (checkedCorpora, checkedSites2) => {
+    breaches.sort((a, b2) => KIND_ORDER.indexOf(a.kind) - KIND_ORDER.indexOf(b2.kind) || (a.key < b2.key ? -1 : a.key > b2.key ? 1 : 0));
+    return {
+      schema: "parseman.wasted-work-verdict/1",
+      ok: breaches.length === 0,
+      breaches,
+      checkedCorpora,
+      checkedSites: checkedSites2
+    };
+  };
+  const b = baseline;
+  if (b === null || b === void 0 || typeof b !== "object") {
+    add("invalid-baseline", "<baseline>", "no baseline supplied \u2014 a gate with no baseline measures nothing, and passing here is how a budget stops being enforced");
+    return finish(0, 0);
+  }
+  if (b.schema !== "parseman.wasted-work-baseline/1") {
+    add("invalid-baseline", "<baseline>", `baseline schema is ${JSON.stringify(b.schema)}, expected "parseman.wasted-work-baseline/1"`);
+    return finish(0, 0);
+  }
+  const isRecord = (v2) => typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
+  if (!isRecord(b.totals) || !isRecord(b.sites)) {
+    add("invalid-baseline", "<baseline>", "baseline `totals` or `sites` is missing or is not an object");
+    return finish(0, 0);
+  }
+  if (Object.keys(b.totals).length === 0) {
+    add("invalid-baseline", "<baseline>", "baseline records ZERO corpora");
+    return finish(0, 0);
+  }
+  const finite = (v2) => typeof v2 === "number" && Number.isFinite(v2);
+  for (const [id, t] of Object.entries(b.totals).sort(([x], [y]) => x < y ? -1 : 1)) {
+    if (!isRecord(t) || !finite(t.corpusBytes) || !finite(t.totalWastedBytes)) {
+      add("invalid-baseline", id, "baseline entry has no finite numeric `corpusBytes` / `totalWastedBytes` \u2014 the comparison against it would silently produce NaN and no breach");
+    }
+  }
+  for (const [key, v2] of Object.entries(b.sites).sort(([x], [y]) => x < y ? -1 : 1)) {
+    if (!finite(v2)) add("invalid-baseline", key, "baseline site value is not a finite number \u2014 the comparison against it would silently produce NaN and no breach");
+  }
+  if (breaches.length > 0) return finish(0, 0);
+  if (policy.ceilingRatio !== void 0) {
+    for (const [id, t] of Object.entries(b.totals).sort(([x], [y]) => x < y ? -1 : 1)) {
+      if (t.corpusBytes > 0 && t.totalWastedBytes / t.corpusBytes > policy.ceilingRatio) {
+        add(
+          "invalid-baseline",
+          id,
+          `baseline records ${t.totalWastedBytes} wasted / ${t.corpusBytes} corpus bytes = ${(t.totalWastedBytes / t.corpusBytes).toFixed(3)}x, above the ${policy.ceilingRatio}x ceiling \u2014 a rebaseline cannot accept an over-ceiling number`
+        );
+      }
+    }
+    if (breaches.length > 0) return finish(0, 0);
+  }
+  if (Object.keys(reports).length === 0) {
+    add("unmeasurable", "<reports>", "no corpus was measured \u2014 refusing to report a pass on an empty measurement");
+    return finish(0, 0);
+  }
+  let checkedSites = 0;
+  for (const id of Object.keys(reports).sort()) {
+    const r = reports[id];
+    if (r.corpusFiles === 0) {
+      add("unmeasurable", id, "report covers ZERO corpus files");
+      continue;
+    }
+    if (r.instrumentedSites === 0) {
+      add("unmeasurable", id, "report instrumented ZERO choice sites \u2014 the total below would be zero for a reason unrelated to the grammar");
+      continue;
+    }
+    if (r.unresolvedRoots.length > 0) {
+      add(
+        "unmeasurable",
+        id,
+        `${r.unresolvedRoots.length} rule(s) could not be resolved and were NOT walked (${r.unresolvedRoots.slice(0, 4).join(", ")}${r.unresolvedRoots.length > 4 ? ", \u2026" : ""}) \u2014 the total is a lower bound over an unknown fraction of the grammar`
+      );
+      continue;
+    }
+    const base = b.totals[id];
+    if (base === void 0) {
+      add("unbaselined", id, `measured but absent from the baseline (${r.totalWastedBytes} wasted bytes over ${r.corpusBytes})`);
+      continue;
+    }
+    if (policy.ceilingRatio !== void 0 && r.corpusBytes > 0) {
+      const ratio = r.totalWastedBytes / r.corpusBytes;
+      if (ratio > policy.ceilingRatio) {
+        add("ceiling", id, `${r.totalWastedBytes} wasted / ${r.corpusBytes} corpus bytes = ${ratio.toFixed(3)}x, over the ${policy.ceilingRatio}x ceiling`);
+      }
+    }
+    if (r.corpusBytes !== base.corpusBytes) {
+      add("unmeasurable", id, `corpus changed: baseline ${base.corpusBytes} bytes, measured ${r.corpusBytes} \u2014 totals are not comparable until the baseline is refreshed`);
+      continue;
+    }
+    const d = pct(r.totalWastedBytes, base.totalWastedBytes);
+    if (d > tolerance) {
+      add("drift", id, `total wasted ${base.totalWastedBytes} -> ${r.totalWastedBytes} bytes (${d >= 0 ? "+" : ""}${d.toFixed(2)}%, band \xB1${tolerance}%)`);
+    } else if (d < -tolerance) {
+      add("shrank", id, `total wasted ${base.totalWastedBytes} -> ${r.totalWastedBytes} bytes (${d.toFixed(2)}%, band \xB1${tolerance}%) \u2014 BANK THE WIN: rebaseline so the ${base.totalWastedBytes - r.totalWastedBytes} bytes you just saved cannot become headroom for the next regression`);
+    }
+    if (r.totalGatedWastedBytes !== r.totalWastedBytes) {
+      const dg = pct(r.totalGatedWastedBytes, base.totalWastedBytes);
+      if (dg > tolerance) {
+        add("drift", id, `compiled-model total wasted ${base.totalWastedBytes} -> ${r.totalGatedWastedBytes} bytes (${dg >= 0 ? "+" : ""}${dg.toFixed(2)}%, band \xB1${tolerance}%) \u2014 the compiled and interpreted columns have PARTED (${r.totalGatedWastedBytes} vs ${r.totalWastedBytes}); the baseline records the interpreted one`);
+      } else if (dg < -tolerance) {
+        add("shrank", id, `compiled-model total wasted ${base.totalWastedBytes} -> ${r.totalGatedWastedBytes} bytes (${dg.toFixed(2)}%, band \xB1${tolerance}%) \u2014 the compiled and interpreted columns have PARTED (${r.totalGatedWastedBytes} vs ${r.totalWastedBytes}); the baseline records the interpreted one`);
+      }
+    }
+    for (const s of r.sites) {
+      const key = `${id}::${s.siteKey}`;
+      const bs = b.sites[key];
+      if (bs === void 0) {
+        if (s.wastedBytes > 0) add("unbaselined", key, `site measured ${s.wastedBytes} wasted bytes but has no baseline entry`);
+        continue;
+      }
+      checkedSites++;
+      const sd = pct(s.wastedBytes, bs);
+      if (sd > tolerance) add("drift", key, `${bs} -> ${s.wastedBytes} bytes (${sd >= 0 ? "+" : ""}${sd.toFixed(2)}%, band \xB1${tolerance}%)`);
+      else if (sd < -tolerance) add("shrank", key, `${bs} -> ${s.wastedBytes} bytes (${sd.toFixed(2)}%, band \xB1${tolerance}%) \u2014 BANK THE WIN: rebaseline, or this site's ${bs - s.wastedBytes} recovered bytes become budget`);
+      if (s.gatedWastedBytes !== s.wastedBytes) {
+        const sg = pct(s.gatedWastedBytes, bs);
+        if (sg > tolerance) add("drift", key, `compiled-model ${bs} -> ${s.gatedWastedBytes} bytes (${sg >= 0 ? "+" : ""}${sg.toFixed(2)}%, band \xB1${tolerance}%) \u2014 columns PARTED (${s.gatedWastedBytes} vs ${s.wastedBytes})`);
+        else if (sg < -tolerance) add("shrank", key, `compiled-model ${bs} -> ${s.gatedWastedBytes} bytes (${sg.toFixed(2)}%, band \xB1${tolerance}%) \u2014 columns PARTED (${s.gatedWastedBytes} vs ${s.wastedBytes})`);
+      }
+    }
+    if (policy.failOnInversions === true) {
+      for (const inv of r.inversions) {
+        add(
+          "inversion",
+          `${id}::${inv.siteKey}#${inv.arm}`,
+          // The GATED columns, because that is what `inversions` was computed from
+          // (choice-cost.ts filters on `gatedAttempts`/`gatedFailures`). Printing the
+          // interpreted counts here would state "failed all N" with an N the condition
+          // never tested — the two differ wherever `firstCharGated` is true.
+          `arm ${inv.arm} (${inv.label}) failed all ${inv.gatedAttempts} compiled entries while a later arm matched; ${inv.gatedWastedBytes} bytes re-scanned`
+        );
+      }
+    }
+  }
+  const measuredKeys = /* @__PURE__ */ new Set();
+  for (const id of Object.keys(reports)) for (const s of reports[id].sites) measuredKeys.add(`${id}::${s.siteKey}`);
+  for (const key of Object.keys(b.sites).sort()) {
+    if (!measuredKeys.has(key)) {
+      add("stale", key, "baselined site matches no measured site \u2014 a rule was renamed or removed, and ignoring it silently shrinks the gated set");
+    }
+  }
+  for (const id of Object.keys(b.totals).sort()) {
+    if (reports[id] === void 0) add("stale", id, "baselined corpus was not measured");
+  }
+  return finish(Object.keys(reports).length, checkedSites);
+}
+function buildWastedWorkBaseline(reports, meta) {
+  const totals = {};
+  const sites = {};
+  for (const id of Object.keys(reports).sort()) {
+    const r = reports[id];
+    totals[id] = { corpusBytes: r.corpusBytes, totalWastedBytes: r.totalWastedBytes, instrumentedSites: r.instrumentedSites };
+    for (const s of [...r.sites].sort((a, c) => a.siteKey < c.siteKey ? -1 : 1)) {
+      if (s.wastedBytes > 0) sites[`${id}::${s.siteKey}`] = s.wastedBytes;
+    }
+  }
+  return { schema: "parseman.wasted-work-baseline/1", gitRev: meta.gitRev, updatedAt: meta.updatedAt, totals, sites };
+}
+
+// src/combinators/gate.ts
+function gate(predicate) {
+  const meta = {
+    firstSet: { kind: "any" },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "guard",
+    _meta: meta,
+    _def: { tag: "guard", predicate },
+    parse(_input, pos, ctx) {
+      if (predicate(ctx.state))
+        return { ok: true, value: null, span: { start: pos, end: pos } };
+      return { ok: false, expected: ["guard"], span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/completions.ts
+function completionsAt(target, input, offset, options = {}) {
+  const probe = { offset, best: null };
+  const ctx = { trackLines: false, _probe: probe, ...options.tolerant ? { _tolerant: true, _rec: REC } : {} };
+  const sliced = input.slice(0, offset);
+  const result = "parseWithContext" in target ? target.parseWithContext(sliced, ctx, 0) : target.parse(sliced, 0, ctx);
+  if (result.ok) return options.tolerant ? probe.best?.expected ?? [] : [];
+  const best = deeperFail(probe.best, result);
+  return best?.expected ?? [];
+}
+function deeperFail(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a.span.start >= b.span.start ? a : b;
+}
+
+// src/cst/relative-spans.ts
+function relativize(node2, parentBase = 0) {
+  return {
+    start: node2.start - parentBase,
+    end: node2.end - parentBase,
+    children: node2.children.map((c) => relativize(c, node2.start))
+  };
+}
+function absolutize(node2, parentBase = 0) {
+  const start = parentBase + node2.start;
+  return {
+    start,
+    end: parentBase + node2.end,
+    children: node2.children.map((c) => absolutize(c, start))
+  };
+}
+function absoluteSpanAt(root, path) {
+  let base = 0;
+  let node2 = root;
+  for (const idx of path) {
+    base += node2.start;
+    const child = node2.children[idx];
+    if (!child) throw new RangeError(`absoluteSpanAt: no child ${idx} on path ${path.join(".")}`);
+    node2 = child;
+  }
+  return { start: base + node2.start, end: base + node2.end };
+}
+function relativizeCST(node2, parentBase = 0) {
+  const span = { start: node2.span.start - parentBase, end: node2.span.end - parentBase };
+  if (node2.children) {
+    const base = node2.span.start;
+    return { ...node2, span, children: node2.children.map((c) => relativizeCST(c, base)) };
+  }
+  return { ...node2, span };
+}
+function absolutizeCST(node2, parentBase = 0) {
+  const start = parentBase + node2.span.start;
+  const span = { start, end: parentBase + node2.span.end };
+  if (node2.children) {
+    return { ...node2, span, children: node2.children.map((c) => absolutizeCST(c, start)) };
+  }
+  return { ...node2, span };
+}
+function absoluteSpanCST(root, path) {
+  let base = 0;
+  let node2 = root;
+  for (const idx of path) {
+    base += node2.span.start;
+    const child = node2.children?.[idx];
+    if (!child) throw new RangeError(`absoluteSpanCST: no child ${idx} on path ${path.join(".")}`);
+    node2 = child;
+  }
+  return { start: base + node2.span.start, end: base + node2.span.end };
+}
+function shiftAbsolute(node2, at, delta) {
+  const s = node2.start >= at ? node2.start + delta : node2.start;
+  const e = node2.end >= at ? node2.end + delta : node2.end;
+  return {
+    start: s,
+    end: e,
+    children: node2.children.map((c) => shiftAbsolute(c, at, delta))
+  };
+}
+function applyEdit(root, at, delta, stats) {
+  return editNode(root, at, delta, 0, 0, stats);
+}
+function editNode(node2, at, delta, parentBase, parentShift, stats) {
+  const absStart = parentBase + node2.start;
+  const absEnd = parentBase + node2.end;
+  if (absEnd < at) return node2;
+  const startShifts = absStart >= at;
+  if (startShifts && parentShift === delta) return node2;
+  if (stats) stats.allocated++;
+  const newAbsStart = startShifts ? absStart + delta : absStart;
+  const newAbsEnd = absEnd + delta;
+  const newParentBase = parentBase + parentShift;
+  const newStart = newAbsStart - newParentBase;
+  const newEnd = newAbsEnd - newParentBase;
+  const ownShift = newAbsStart - absStart;
+  let changed = false;
+  const newChildren = [];
+  for (const c of node2.children) {
+    const nc = editNode(c, at, delta, absStart, ownShift, stats);
+    if (nc !== c) changed = true;
+    newChildren.push(nc);
+  }
+  return {
+    start: newStart,
+    end: newEnd,
+    children: changed ? newChildren : node2.children
+  };
+}
+
+// src/functional/doc.ts
+function mkCtx(rawState, build, tolerant) {
+  const state = rawState ?? void 0;
+  return tolerant ? { trackLines: false, state, build, _tolerant: true, _rec: REC, _errors: [] } : { trackLines: false, state, build };
+}
+function asRuleFn(entry) {
+  return typeof entry === "function" ? entry : (input, pos, ctx) => entry.parse(input, pos, ctx);
 }
 function defOf(entry) {
   return typeof entry === "object" && entry !== null && "_def" in entry ? entry._def : void 0;
@@ -12580,145 +13707,6 @@ function parseDoc(registry, rootRule, input, opts = {}) {
   return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input);
 }
 
-// src/functional/run.ts
-var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
-var REMOVED_RUN_RESULT_FIELDS = [
-  [
-    "triviaMap",
-    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
-  ],
-  [
-    "triviaLog",
-    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
-  ],
-  [
-    "triviaKindLabels",
-    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
-  ]
-];
-function guardRemovedFields(result) {
-  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
-    Object.defineProperty(result, name, {
-      configurable: true,
-      enumerable: false,
-      get() {
-        throw new TypeError(
-          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
-        );
-      }
-    });
-  }
-  return result;
-}
-var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
-function triviaKindLabelsFromRunnable(r) {
-  if (!r) return void 0;
-  if (typeof r === "function") return r._meta?.triviaKindLabels;
-  const grammarTrivia = r._meta.grammarTrivia;
-  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
-}
-function rootTriviaClassifiedFromRunnable(r) {
-  if (!r) return false;
-  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
-  const grammarTrivia = r._meta.grammarTrivia;
-  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
-}
-function makeSelectedRootLabelIndex(labels) {
-  const index = /* @__PURE__ */ Object.create(null);
-  for (let i = 0; i < labels.length; i++) {
-    if (index[labels[i]] === void 0) index[labels[i]] = i;
-  }
-  return index;
-}
-function runOnce(entry, input, options, phase, profileState) {
-  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
-    throw new TypeError(
-      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
-    );
-  }
-  const rootTriviaSelection = options.rootTrivia?.select;
-  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
-  const selectedRootLog = captureRootTrivia ? [] : void 0;
-  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
-  const errors = [];
-  const profile = profileState ?? (phase === void 0 ? void 0 : { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 });
-  const skipGlobalSinks = phase === "recognizer" || phase === "capture";
-  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
-  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
-  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
-  if (captureRootTrivia && triviaKindLabels === void 0) {
-    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
-  }
-  if (captureRootTrivia) {
-    for (const label2 of rootTriviaSelection) {
-      if (!triviaKindLabels.includes(label2)) {
-        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
-      }
-    }
-  }
-  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
-    throw new TypeError(
-      "run(): rootTrivia.select requires classifiedTrivia() at the root."
-    );
-  }
-  const stamped = entry;
-  assertHostModeCompatible(
-    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
-    options.build,
-    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
-  );
-  const ctx = {
-    trackLines: false,
-    ...skipGlobalSinks ? { _pmProfile: profile } : {
-      ...captureRootTrivia ? {
-        _rootTriviaLog: selectedRootLog,
-        _rootTriviaKindIndex: selectedRootLabelIndex,
-        _rootTriviaStrictScopes: true
-      } : {},
-      _errors: errors,
-      ...profile === void 0 ? {} : { _pmProfile: profile }
-    },
-    build: options.build,
-    state: options.state,
-    ...grammarTrivia !== void 0 ? { trivia: grammarTrivia, ...triviaKindLabels ? { triviaKindLabels } : {} } : triviaKindLabels ? { triviaKindLabels } : {},
-    ...grammarScanSkip !== void 0 ? { scanSkip: grammarScanSkip } : {},
-    ...options.triviaCaptureMask !== void 0 ? { _triviaCaptureMask: options.triviaCaptureMask } : {},
-    ...options.tolerant ? { _tolerant: true, _rec: REC } : {},
-    ...options.instrumentation === void 0 ? {} : options.instrumentation
-  };
-  const r = invoke(entry, input, 0, ctx);
-  let unconsumedFrom = null;
-  if (r.ok) {
-    let pos = r.span?.end ?? 0;
-    if (options.trivia && pos < input.length) {
-      const t = invoke(options.trivia, input, pos, { trackLines: false });
-      if (t.ok && t.span.end > pos) pos = t.span.end;
-    }
-    unconsumedFrom = pos < input.length ? pos : null;
-  }
-  return {
-    ok: r.ok,
-    value: r.ok ? r.value : void 0,
-    span: r.span ?? { start: 0, end: 0 },
-    expected: r.ok ? [] : r.expected ?? [],
-    errors,
-    ...selectedRootLog !== void 0 && selectedRootLog.length > 0 ? {
-      rootTrivia: {
-        rows: selectedRootLog,
-        select: rootTriviaSelection,
-        index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
-      }
-    } : {},
-    unconsumedFrom
-  };
-}
-function run(entry, input, options = {}) {
-  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options));
-  throw new TypeError(
-    "run({ profile: true }) is unavailable: profiling counters are no longer compiled into parser artifacts, and the interpreter does not implement them yet. Profiling is moving to interpreted mode."
-  );
-}
-
 // src/coverage.ts
 function dispatchMatcher(entry) {
   switch (entry.kind) {
@@ -13166,6 +14154,7 @@ export {
   absolutize,
   absolutizeCST,
   alternationGroups,
+  analyzeChoiceInventory,
   analyzeDuplication,
   analyzeDuplicationRules,
   analyzeGating,
@@ -13174,13 +14163,17 @@ export {
   annotateSpan,
   annotateTreeSpans,
   applyEdit,
+  armLabel,
   attempt,
   balanced,
   buildLineIndex,
   buildRootTriviaIndex,
   buildTriviaIndex,
+  buildWastedWorkBaseline,
   charClassMembers,
+  checkWastedWork,
   choice,
+  choiceSiteKey,
   classifiedTrivia,
   compile,
   compiledGrammarCoverageDefinitions,
@@ -13198,6 +14191,7 @@ export {
   dispatch,
   duplicationFindingCount,
   endsWith,
+  examinedNothing,
   expect,
   extractCharClasses,
   field,
@@ -13205,14 +14199,17 @@ export {
   formatDuplicationFindings,
   formatGatingWarnings,
   formatGrammarDiagnosis,
+  fuseInterpreted,
   gate,
   grammarCoverageDefinitions,
+  isInterpretedFuse,
   isParseError,
   keywordAlternationHazards,
   keywordRegexShape,
   keywords,
   label,
   leaf,
+  leftFactorPreview,
   literal,
   makeWhen,
   makeWord,
@@ -13231,11 +14228,14 @@ export {
   parseDoc,
   parser,
   peek,
+  profileWastedWork,
   recordLineRange,
   ref,
   regex,
   relativize,
   relativizeCST,
+  renderChoiceInventory,
+  renderWastedWork,
   routed,
   rules,
   run,