parseman 0.44.0 → 0.46.0

package/dist/index.cjs

@@ -21,12 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   GRAMMAR_COVERAGE_DEFINITIONS: () => GRAMMAR_COVERAGE_DEFINITIONS,
-  OffsetIndex: () => OffsetIndex,
   absoluteSpanAt: () => absoluteSpanAt,
   absoluteSpanCST: () => absoluteSpanCST,
   absolutize: () => absolutize,
   absolutizeCST: () => absolutizeCST,
   alternationGroups: () => alternationGroups,
+  analyzeChoiceInventory: () => analyzeChoiceInventory,
   analyzeDuplication: () => analyzeDuplication,
   analyzeDuplicationRules: () => analyzeDuplicationRules,
   analyzeGating: () => analyzeGating,
@@ -35,18 +35,18 @@ __export(index_exports, {
   annotateSpan: () => annotateSpan,
   annotateTreeSpans: () => annotateTreeSpans,
   applyEdit: () => applyEdit,
+  armLabel: () => armLabel,
   attempt: () => attempt,
   balanced: () => balanced,
-  blankLinesIn: () => blankLinesIn,
   buildLineIndex: () => buildLineIndex,
-  buildOffsetIndex: () => buildOffsetIndex,
   buildRootTriviaIndex: () => buildRootTriviaIndex,
   buildTriviaIndex: () => buildTriviaIndex,
+  buildWastedWorkBaseline: () => buildWastedWorkBaseline,
   charClassMembers: () => charClassMembers,
+  checkWastedWork: () => checkWastedWork,
   choice: () => choice,
+  choiceSiteKey: () => choiceSiteKey,
   classifiedTrivia: () => classifiedTrivia,
-  collectLeafSlots: () => collectLeafSlots,
-  commentsIn: () => commentsIn,
   compile: () => compile,
   compiledGrammarCoverageDefinitions: () => compiledGrammarCoverageDefinitions,
   completionsAt: () => completionsAt,
@@ -59,30 +59,29 @@ __export(index_exports, {
   createLineIndex: () => createLineIndex,
   createVisitor: () => createVisitor,
   cstBuildHost: () => cstBuildHost,
+  diagnoseGrammar: () => diagnoseGrammar,
   dispatch: () => dispatch,
   duplicationFindingCount: () => duplicationFindingCount,
   endsWith: () => endsWith,
+  examinedNothing: () => examinedNothing,
   expect: () => expect,
   extractCharClasses: () => extractCharClasses,
   field: () => field,
   firstSetToString: () => firstSetToString,
   formatDuplicationFindings: () => formatDuplicationFindings,
   formatGatingWarnings: () => formatGatingWarnings,
-  gapIsSignificant: () => gapIsSignificant,
-  gapText: () => gapText,
+  formatGrammarDiagnosis: () => formatGrammarDiagnosis,
+  fuseInterpreted: () => fuseInterpreted,
   gate: () => gate,
   grammarCoverageDefinitions: () => grammarCoverageDefinitions,
-  guard: () => guard,
-  indentMixed: () => indentMixed,
-  indentWidth: () => indentWidth,
+  isInterpretedFuse: () => isInterpretedFuse,
   isParseError: () => isParseError,
   keywordAlternationHazards: () => keywordAlternationHazards,
   keywordRegexShape: () => keywordRegexShape,
   keywords: () => keywords,
   label: () => label,
   leaf: () => leaf,
-  lineBreaksIn: () => lineBreaksIn,
-  lineStartWithin: () => lineStartWithin,
+  leftFactorPreview: () => leftFactorPreview,
   literal: () => literal,
   makeWhen: () => makeWhen,
   makeWord: () => makeWord,
@@ -101,11 +100,14 @@ __export(index_exports, {
   parseDoc: () => parseDoc,
   parser: () => parser,
   peek: () => peek,
+  profileWastedWork: () => profileWastedWork,
   recordLineRange: () => recordLineRange,
   ref: () => ref,
   regex: () => regex,
   relativize: () => relativize,
   relativizeCST: () => relativizeCST,
+  renderChoiceInventory: () => renderChoiceInventory,
+  renderWastedWork: () => renderWastedWork,
   routed: () => routed,
   rules: () => rules,
   run: () => run,
@@ -181,8 +183,9 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
       return d.value.length === 0;
     case "keywords":
       return false;
+    // The routed token itself is the selector's match, never empty; a fallback can be.
     case "routed":
-      return false;
+      return d.fallback === void 0 ? false : me(d.fallback);
     case "regex":
       try {
         const m = new RegExp(d.source).exec("");
@@ -1944,8 +1947,11 @@ function derive(c, seen) {
     case "not":
     case "peek":
       return deriveExpected2(def.parser);
+    // A bare routed() can only fail as "there is no routed token here". With a
+    // fallback, THAT is the branch that can fail, so its expectations are the useful
+    // ones — the routed path either succeeds or is not taken.
     case "routed":
-      return ["routed()"];
+      return def.fallback === void 0 ? ["routed()"] : deriveExpected2(def.fallback);
     case "lazy": {
       const name = c._ruleName;
       if (seen.has(c)) return name ? [name] : [];
@@ -2135,7 +2141,7 @@ function detectStrategy(parsers) {
 function bareLeadingTermKey(term) {
   const d = term._def;
   if (d.tag === "literal" && !d.caseInsensitive) return `L:${d.value}`;
-  if (d.tag === "regex") return `R:${d.source}\0${d.flags}`;
+  if (d.tag === "regex") return `R:${JSON.stringify([d.source, d.flags])}`;
   return null;
 }
 function detectSharedPrefix(parsers) {
@@ -2393,17 +2399,21 @@ function makeWhen(opts = {}) {
 function otherwise(parser2) {
   return { kind: "otherwise", parser: parser2, usesRouted: parserUsesRouted(parser2) };
 }
-function routed() {
+function routed(fallback) {
   return {
     _tag: "routed",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "routed" },
+    _meta: {
+      // The routed token is whatever the selector matched, so the first set stays
+      // `any` even with a fallback — `any` already subsumes the fallback's.
+      firstSet: { kind: "any" },
+      canMatchNewline: fallback?._meta.canMatchNewline ?? false,
+      isTrivia: false
+    },
+    _def: fallback === void 0 ? { tag: "routed" } : { tag: "routed", fallback },
     parse(_input, pos, ctx) {
       const item = ctx._routed;
-      if (item === void 0) {
-        return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
-      }
-      if (pos !== item.span.start) {
+      if (item === void 0 || pos !== item.span.start) {
+        if (fallback !== void 0) return fallback.parse(_input, pos, ctx);
         return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
       }
       if (cstCaptureActive(ctx)) {
@@ -2946,13 +2956,13 @@ function markUnusedValues(root) {
         return;
     }
   };
-  const resolveRoot = (c) => {
-    const guard2 = /* @__PURE__ */ new Set();
+  const resolveRoot2 = (c) => {
+    const guard = /* @__PURE__ */ new Set();
     let cur = c;
-    while (!guard2.has(cur)) {
+    while (!guard.has(cur)) {
       const d = cur._def;
       if (d.tag !== "lazy") return cur;
-      guard2.add(cur);
+      guard.add(cur);
       try {
         cur = d.thunk();
       } catch {
@@ -2961,7 +2971,7 @@ function markUnusedValues(root) {
     }
     return cur;
   };
-  visit(resolveRoot(root), true);
+  visit(resolveRoot2(root), true);
 }
 
 // src/combinators/grammar.ts
@@ -3121,10 +3131,11 @@ function childrenOf(def) {
       return [def.main, def.skipped];
     case "scanTo":
       return [def.sentinel, ...def.skip];
+    case "routed":
+      return def.fallback ? [def.fallback] : [];
     case "literal":
     case "regex":
     case "keywords":
-    case "routed":
     case "guard":
     case "lazy":
     case "unknown":
@@ -3350,54 +3361,272 @@ function peek(combinator) {
   };
 }
 
+// src/compiler/degradation.ts
+function formatDegradation(d) {
+  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
+}
+var DETAIL_CAP = 8;
+function formatDegradations(list) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const d of list) {
+    const bucket = byCode.get(d.code);
+    if (bucket) bucket.push(d);
+    else byCode.set(d.code, [d]);
+  }
+  const out = [];
+  for (const [code, items] of byCode) {
+    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
+    if (items.length > DETAIL_CAP) {
+      out.push(
+        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
+      );
+    }
+  }
+  return out;
+}
+var _sinks = [];
+function beginDegradationCapture() {
+  _sinks.push(/* @__PURE__ */ new Map());
+}
+function degradationCaptureDepth() {
+  return _sinks.length;
+}
+function unwindDegradationCapture(depth) {
+  const found = [];
+  while (_sinks.length > depth) {
+    const sink = _sinks.pop();
+    found.unshift(...sink.values());
+  }
+  return found;
+}
+function resolveDegradationLevel(explicit) {
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
+  if (env === "off" || env === "warn" || env === "error") return env;
+  return "warn";
+}
+function degradationKey(d) {
+  return JSON.stringify([d.code, d.where, d.subject]);
+}
+function recordDegradation(d) {
+  const level = resolveDegradationLevel();
+  if (level === "off") return;
+  const key = degradationKey(d);
+  const sink = _sinks[_sinks.length - 1];
+  if (sink) {
+    if (!sink.has(key)) sink.set(key, d);
+    return;
+  }
+  if (_immediate.has(key)) return;
+  _immediate.add(key);
+  if (level === "error") throw new Error(`parseman: degraded compilation path
+${formatDegradation(d)}`);
+  console.warn(formatDegradation(d));
+}
+var _immediate = /* @__PURE__ */ new Set();
+function beginCompileDegradationDrain() {
+  if (resolveDegradationLevel() === "off" || _sinks.length > 0) return () => {
+  };
+  const depth = degradationCaptureDepth();
+  beginDegradationCapture();
+  return (report) => {
+    const found = unwindDegradationCapture(depth);
+    if (!report || found.length === 0) return;
+    const fresh = found.filter((d) => {
+      const k = degradationKey(d);
+      if (_immediate.has(k)) return false;
+      _immediate.add(k);
+      return true;
+    });
+    if (fresh.length === 0) return;
+    const lines = formatDegradations(fresh);
+    if (resolveDegradationLevel() === "error") {
+      throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
+${lines.join("\n")}`);
+    }
+    for (const l of lines) console.warn(l);
+  };
+}
+
 // src/compiler/build-arity.ts
 function cstOutputHost(build) {
   return build?._parsemanCstOutput === true;
 }
-var PARAM_LIST_RE = (
-  // (params) => ...   |   function name?(params) ...   |   single-ident arrow `x => ...`
-  /^(?:function\b[^(]*\(([^)]*)\)|\(([^)]*)\)\s*=>|([A-Za-z_$][\w$]*)\s*=>)/
-);
-var CONFIRMABLE_PARAM_RE = /^[A-Za-z_$][\w$]*\s*\??\s*(?::[^,=]+)?$/;
+var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
+var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
+var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
+var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
 function confirmedBuildArity(src) {
   const s = src.trim();
-  const m = PARAM_LIST_RE.exec(s);
-  if (!m) return null;
-  if (m[3] !== void 0) return 1;
-  const inner = (m[1] ?? m[2] ?? "").trim();
-  if (inner === "") return 0;
-  const parts = inner.split(",");
+  if (NATIVE_CODE_RE.test(s)) return null;
+  if (/\barguments\b/.test(s)) return null;
+  if (SINGLE_IDENT_ARROW_RE.test(s)) return 1;
+  const inner = paramListText(s);
+  if (inner === null) return null;
+  if (inner.trim() === "") return 0;
+  const parts = splitTopLevel(inner);
+  if (parts === null) return null;
   for (const part of parts) {
-    if (!CONFIRMABLE_PARAM_RE.test(part.trim())) return null;
+    if (!isConfirmableParam(part.trim())) return null;
   }
-  if (/\barguments\b/.test(s)) return null;
   return parts.length;
 }
+function paramListText(s) {
+  const open = PARAM_LIST_OPEN_RE.exec(s);
+  if (!open) return null;
+  const start = open[0].length;
+  const end = matchingParen(s, start);
+  if (end === null) return null;
+  if (!s.startsWith("function") && !/^\s*=>/.test(s.slice(end + 1))) return null;
+  return s.slice(start, end);
+}
+function matchingParen(s, start) {
+  let depth = 0;
+  for (let i = start; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(s, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === ")") {
+      if (depth === 0) return i;
+      depth--;
+    }
+  }
+  return null;
+}
+function skipString(s, open) {
+  const quote = s[open];
+  for (let i = open + 1; i < s.length; i++) {
+    if (s[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (s[i] === quote) return i;
+  }
+  return null;
+}
+function splitTopLevel(inner) {
+  const parts = [];
+  let depth = 0;
+  let angle = 0;
+  let last = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const c = inner[i];
+    if (c === "=" && inner[i + 1] === ">") {
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      const close = skipString(inner, i);
+      if (close === null) return null;
+      i = close;
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") {
+      if (--depth < 0) return null;
+    } else if (c === "<") angle++;
+    else if (c === ">") {
+      if (--angle < 0) return null;
+    } else if (c === "," && depth === 0 && angle === 0) {
+      parts.push(inner.slice(last, i));
+      last = i + 1;
+    }
+  }
+  if (depth !== 0 || angle !== 0) return null;
+  parts.push(inner.slice(last));
+  return parts;
+}
+function isConfirmableParam(part) {
+  const head = PARAM_HEAD_RE.exec(part);
+  if (!head) return false;
+  const rest = part.slice(head[0].length);
+  if (rest === "") return true;
+  if (rest[0] !== ":") return false;
+  return !hasDefaultAssign(rest.slice(1));
+}
+function hasDefaultAssign(annotation) {
+  for (let i = 0; i < annotation.length; i++) {
+    if (annotation[i] !== "=") continue;
+    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
+      i++;
+      continue;
+    }
+    const prev = annotation[i - 1];
+    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
+    return true;
+  }
+  return false;
+}
+function buildAnalysisSrc(def) {
+  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
+}
+var RESOLVER_REASONS = {
+  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
+  "arguments": "its body references `arguments`",
+  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
+  "not-a-function": "the binding it names is not a function declaration",
+  "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 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;
+  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
+  const s = src.trim();
+  const params = s.slice(0, s.indexOf(")") + 1);
+  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
+  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
+  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
+    return "it names a binding this build could not resolve to a function declaration";
+  }
+  return "its parameter list could not be parsed";
+}
+function confirmedArityForDef(def) {
+  if (def.buildArity !== void 0) return def.buildArity;
+  const src = buildAnalysisSrc(def);
+  const arity = confirmedBuildArity(src);
+  if (arity !== null) return arity;
+  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
+  recordDegradation({
+    code: "build-arity-unconfirmed",
+    severity: "warn",
+    where: `node("${def.type ?? "<inferred>"}")`,
+    subject,
+    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and clones \`_ctx.state\` on every match`,
+    otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
+  });
+  return null;
+}
 function buildReadsChildren(def) {
   if (!def.build) return true;
-  const src = def.buildSrc ?? def.build.toString();
-  const arity = confirmedBuildArity(src);
+  const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 1;
 }
 function buildReadsRaw(def) {
   if (!def.build) return true;
-  const src = def.buildSrc ?? def.build.toString();
-  const arity = confirmedBuildArity(src);
+  const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 4;
 }
 function buildReadsTrivia(def) {
   if (!def.build) return true;
-  const src = def.buildSrc ?? def.build.toString();
-  const arity = confirmedBuildArity(src);
+  const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 5;
 }
 function buildReadsState(def) {
   if (!def.build) return true;
-  const src = def.buildSrc ?? def.build.toString();
-  const arity = confirmedBuildArity(src);
+  const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 6;
 }
@@ -3405,8 +3634,7 @@ function buildReadsState(def) {
 // src/compiler/fields.ts
 function buildReadsFields(def) {
   if (!def.build) return true;
-  const src = def.buildSrc ?? def.build.toString();
-  const arity = confirmedBuildArity(src);
+  const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 2;
 }
@@ -3587,6 +3815,13 @@ function isCstChild(value) {
 function missingInferredType() {
   throw new Error('node(): inferred node type requires a rules() key; pass node("Type", parser) outside rules()');
 }
+function normalizeBuildArity(arity) {
+  if (arity === void 0) return void 0;
+  if (!Number.isInteger(arity) || arity < 0 || arity > 6) {
+    throw new Error("node() buildArity must be an integer 0..6 (children, fields, span, rawChildren, triviaLog, state)");
+  }
+  return arity;
+}
 function normalizeProject(project) {
   if (project === void 0) return void 0;
   if (!Number.isInteger(project) || project < 0) {
@@ -3622,13 +3857,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const captureTrivia = opts?.captureTrivia === true;
   const trailingTrivia = opts?.trailingTrivia === true;
   const tags = opts?.tags;
+  const buildArity = normalizeBuildArity(opts?.buildArity);
   if (unwrap && collapse) {
     throw new Error("node() options cannot set both unwrap and collapse");
   }
   if (project !== void 0 && (unwrap || collapse)) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
@@ -3674,7 +3910,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -3869,7 +4105,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.44.0";
+var PARSEMAN_VERSION = "0.46.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3924,14 +4160,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 } : {} });
@@ -4047,7 +4297,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) => {
@@ -4060,14 +4309,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."
         });
       }
     }
@@ -4076,7 +4325,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.`
       });
     }
   });
@@ -4118,7 +4367,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;
@@ -4147,13 +4396,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;
@@ -4180,7 +4431,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++)
@@ -4190,7 +4448,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";
@@ -4744,7 +5002,7 @@ function findDivergentSlot(members, shapeOf) {
   const path = [];
   const defs = [];
   let cur = [...members];
-  for (let guard2 = 0; guard2 < 64; guard2++) {
+  for (let guard = 0; guard < 64; guard++) {
     const d0 = cur[0]._def;
     const kidLists = cur.map((c) => childrenOf2(c._def));
     const arity = kidLists[0].length;
@@ -5703,7 +5961,15 @@ function children(def, winners) {
       let resolved;
       try {
         resolved = def.thunk();
-      } catch {
+      } catch (e) {
+        recordDegradation({
+          code: "coverage-definitions-unavailable",
+          severity: "warn",
+          where: "<lazy rule reference>",
+          subject: `unresolvable reference (${e.message})`,
+          fellBackTo: "the coverage walk stopped at this reference, so every definition below it is ABSENT from the denominator \u2014 which raises the reported ratio rather than lowering it",
+          otherwise: "the referenced rule and its whole subtree would contribute definitions"
+        });
         return [];
       }
       const name = resolved._ruleName;
@@ -5994,15 +6260,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];
@@ -6012,8 +6278,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) {
@@ -7204,27 +7470,53 @@ function emitScannableTerminal(shape, c) {
 }
 
 // src/compiler/inline-build.ts
-var MK_BUILD_RE = /^\(\s*(\w+)\s*,\s*\w+\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$/;
+var ANN = String.raw`\s*\??\s*(?::[^,)=]+)?`;
+var ANY_P = String.raw`\w+${ANN}`;
+var MK_BUILD_RE = new RegExp(
+  String.raw`^\(\s*(\w+)${ANN}\s*,\s*${ANY_P}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*\)\s*=>\s*mk\s*\(\s*(['"])([^'"]+)\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
+);
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function identMkBuildRe(typeIdent) {
+  return new RegExp(
+    String.raw`^\(\s*(\w+)${ANN}\s*,\s*${ANY_P}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*\)\s*=>\s*(?:[\w$.]*\.)?mk\s*\(\s*${escapeRegExp(typeIdent)}\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
+  );
+}
 function looseMkBuildRe(type) {
   return new RegExp(
-    String.raw`^\(\s*(\w+)\s*,\s*\w+\s*,\s*(\w+)\s*,\s*(\w+)\s*,\s*(\w+)\s*\)\s*=>\s*.+\(\s*(['"])${escapeRegExp(type)}\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
+    String.raw`^\(\s*(\w+)${ANN}\s*,\s*${ANY_P}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*,\s*(\w+)${ANN}\s*\)\s*=>\s*.+\(\s*(['"])${escapeRegExp(type)}\5\s*,\s*\1\s*,\s*\3\s*,\s*\2\s*,\s*\4\s*\)\s*$`
   );
 }
+var LOOKS_LIKE_MK_RE = /=>\s*(?:[\w$.]*\.)?mk\s*\(/;
 function analyzeMkInlineBuild(def) {
   if (!def.build) return null;
   if (def.type === void 0) return null;
-  const src = (def.buildSrc ?? def.build.toString()).trim();
+  const src = buildAnalysisSrc(def).trim();
   const strict = src.match(MK_BUILD_RE);
   if (strict) {
     const mkType = strict[6];
-    return mkType === def.type ? def.type : null;
+    if (mkType === def.type) return def.type;
+    reportMkMiss(def.type, src, `it builds a "${mkType}" node, not "${def.type}"`);
+    return null;
   }
   if (looseMkBuildRe(def.type).test(src)) return def.type;
+  if (def.typeSrc !== void 0 && identMkBuildRe(def.typeSrc).test(src)) return def.type;
+  if (LOOKS_LIKE_MK_RE.test(src)) {
+    reportMkMiss(def.type, src, "its parameter list or argument order does not match `(children, fields, span, rawChildren, triviaLog) => mk(type, children, rawChildren, span, triviaLog)`");
+  }
   return null;
 }
+function reportMkMiss(type, src, why) {
+  recordDegradation({
+    code: "mk-inline-missed",
+    severity: "warn",
+    where: `node("${type}")`,
+    subject: `build reducer \`${src.split("\n")[0].slice(0, 80)}\``,
+    fellBackTo: `looks like an inline-\`mk\` builder but ${why}, so every match pays a \`_build[n](...)\` call instead of an inlined object literal`,
+    otherwise: "the node object would be constructed at the call site with no call frame"
+  });
+}
 function emitInlineMkNodeExpr(type, chV, rawV, spanExpr, tlV) {
   return `{ _tag: 'node', type: ${JSON.stringify(type)}, span: ${spanExpr}, children: ${chV}, rawCount: ${rawV}.length, localTriviaLen: ${tlV}.length }`;
 }
@@ -7407,10 +7699,34 @@ function leadingFirstSetRecipe(p, seen = /* @__PURE__ */ new Set()) {
     seen.delete(p);
   }
 }
+function tern(cond, whenTrue, whenFalse) {
+  if (cond === "false") return whenFalse;
+  if (cond === "true") return whenTrue;
+  return `${cond} ? ${whenTrue} : ${whenFalse}`;
+}
+function notGate(cond) {
+  if (cond === "false") return "true";
+  if (cond === "true") return "false";
+  return `!(${cond})`;
+}
+function orGate(a, b) {
+  if (a === "false") return b;
+  if (b === "false") return a;
+  if (a === "true" || b === "true") return "true";
+  return `${a} || ${b}`;
+}
+function andGate(a, b) {
+  if (a === "false" || b === "false") return "false";
+  if (a === "true") return b;
+  if (b === "true") return a;
+  return `${a} && ${b}`;
+}
 var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
+var RAW_ENTRY_DECL = "const _rawEntry = (v, input, s, e, span) => (typeof v === 'object' && v !== null && (v._tag === 'node' || v._tag === 'leaf' || v._tag === 'parseError')) ? v : { _tag: 'leaf', value: typeof v === 'string' ? v : (typeof v === 'object' && v !== null ? input.slice(s, e) : ''), span: span ?? { start: s, end: e } }";
 var LINE_TRACK_DECL = "const _trackLines = (_ctx, input, start, end) => { const from = _ctx._lineScannedTo ?? 0; if (end <= from) return; for (let i = from; i < end; i++) if (input.charCodeAt(i) === 10) _ctx._lineStarts.push(i + 1); _ctx._lineScannedTo = end }";
 var LINE_SPAN_DECL = "const _lineCol = (_ctx, offset) => { const starts = _ctx._lineStarts; let lo = 0, hi = starts.length - 1; while (lo < hi) { const mid = (lo + hi + 1) >> 1; if (starts[mid] <= offset) lo = mid; else hi = mid - 1 } return [lo + 1, offset - starts[lo] + 1] }\nconst _spanLines = (_ctx, start, end) => { const s = _lineCol(_ctx, start), e = _lineCol(_ctx, end); return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] } }";
 var _loweringSink = null;
+var _inlineCapSink = null;
 function hasSelectedRootTrivia(ctx) {
   return ctx.rootTriviaClassified === true;
 }
@@ -8159,9 +8475,11 @@ function emitSeqValues(def, ctx, pos) {
         const markLog = v(ctx, "_mklg");
         const markRootLog = hasSelectedRootTrivia(ctx) ? v(ctx, "_mkrlg") : null;
         const scanEndV = v(ctx, "_sne");
-        const capArg = ctx.noHoist ? "0" : hasSelectedRootTrivia(ctx) ? "(_ctx._triviaLog !== undefined || _ctx._rootTriviaLog !== undefined) ? 2 : 0" : "_ctx._triviaLog !== undefined ? 2 : 0";
+        const logV = v(ctx, "_tlg");
+        const capArg = ctx.noHoist ? "0" : hasSelectedRootTrivia(ctx) ? `(${logV} !== undefined || _ctx._rootTriviaLog !== undefined) ? 2 : 0` : `${logV} !== undefined ? 2 : 0`;
         stmts.push(
-          `${ind(ctx)}const ${markLog} = _ctx._triviaLog ? _ctx._triviaLog.length : 0`,
+          `${ind(ctx)}const ${logV} = _ctx._triviaLog`,
+          `${ind(ctx)}const ${markLog} = ${logV} !== undefined ? ${logV}.length : 0`,
           ...markRootLog ? [`${ind(ctx)}const ${markRootLog} = _ctx._rootTriviaLog ? _ctx._rootTriviaLog.length : 0`] : [],
           `${ind(ctx)}const ${scanEndV} = ${trivFn}(input, ${curV}, _ctx, ${capArg})`,
           ...emitLineTrack(ctx, curV, scanEndV)
@@ -8171,7 +8489,7 @@ function emitSeqValues(def, ctx, pos) {
         const endAfterV = v(ctx, "_sea");
         stmts.push(
           `${ind(ctx)}const ${endAfterV} = ${r2.endVar}`,
-          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}; else { if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} }`
+          `${ind(ctx)}if (${endAfterV} > ${scanEndV}) ${curV} = ${endAfterV}; else { if (${logV} !== undefined && ${logV}.length !== ${markLog}) ${logV}.length = ${markLog};${markRootLog ? ` if (_ctx._rootTriviaLog && _ctx._rootTriviaLog.length !== ${markRootLog}) _ctx._rootTriviaLog.length = ${markRootLog};` : ""} }`
         );
         valueVars.push(r2.valueVar);
         continue;
@@ -9243,9 +9561,18 @@ function emitPeek(def, ctx, pos) {
     endVar: pos
   };
 }
-function emitRouted(ctx, pos) {
+function emitRouted(ctx, pos, def) {
   const local = ctx.routedLocal;
+  const fallback = def.fallback;
   if (local !== void 0) {
+    if (fallback !== void 0 && local.startVar !== pos) {
+      return emitRoutedWithFallback(ctx, pos, fallback, {
+        test: `${local.startVar} === ${pos}`,
+        valExpr: local.valueVar,
+        startExpr: local.startVar,
+        endExpr: local.endVar
+      });
+    }
     return {
       stmts: [
         ...emitIfFail(ctx, `${local.startVar} !== ${pos}`, failBody(ctx, '"routed()"', pos)),
@@ -9256,9 +9583,19 @@ function emitRouted(ctx, pos) {
     };
   }
   const item = v(ctx, "_rt");
+  const read = `${ind(ctx)}const ${item} = _ctx._routed`;
+  if (fallback !== void 0) {
+    const r = emitRoutedWithFallback(ctx, pos, fallback, {
+      test: `${item} !== undefined && ${item}.span.start === ${pos}`,
+      valExpr: `${item}.value`,
+      startExpr: `${item}.span.start`,
+      endExpr: `${item}.span.end`
+    });
+    return { ...r, stmts: [read, ...r.stmts] };
+  }
   return {
     stmts: [
-      `${ind(ctx)}const ${item} = _ctx._routed`,
+      read,
       ...emitIfFail(ctx, `${item} === undefined || ${item}.span.start !== ${pos}`, failBody(ctx, '"routed()"', pos)),
       ...emitLeafCapture(ctx, `${item}.value`, `${item}.span.start`, `${item}.span.end`)
     ],
@@ -9266,6 +9603,30 @@ function emitRouted(ctx, pos) {
     endVar: `${item}.span.end`
   };
 }
+function emitRoutedWithFallback(ctx, pos, fallback, routed2) {
+  const valV = v(ctx, "_rtv");
+  const endV = v(ctx, "_rte");
+  const i = ind(ctx);
+  ctx.indent++;
+  const capture = emitLeafCapture(ctx, routed2.valExpr, routed2.startExpr, routed2.endExpr);
+  const fb = emit(fallback, ctx, pos);
+  const inner = ind(ctx);
+  ctx.indent--;
+  return {
+    stmts: [
+      `${i}let ${valV}, ${endV}`,
+      `${i}if (${routed2.test}) {`,
+      ...capture,
+      `${inner}${valV} = ${routed2.valExpr}; ${endV} = ${routed2.endExpr}`,
+      `${i}} else {`,
+      ...fb.stmts,
+      `${inner}${valV} = ${fb.valueVar}; ${endV} = ${fb.endVar}`,
+      `${i}}`
+    ],
+    valueVar: valV,
+    endVar: endV
+  };
+}
 function escapeTokenLiteral(value) {
   return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
@@ -9447,22 +9808,16 @@ function emitNode(def, ctx, pos) {
   const smk = structural ? v(ctx, "_smk") : null;
   if (structural) ctx.needsHostReads = true;
   const hostTriviaGate = `_ctx.build !== undefined && (_ctx.build._parsemanCaptureTrivia !== undefined ? _ctx.build._parsemanCaptureTrivia(${JSON.stringify(def.type)}) : (_ctx._pmCapTL ??= _hostReads(_ctx.build, 5)))`;
-  const pmV = v(ctx, "_pm"), recV = v(ctx, "_rec"), capV = v(ctx, "_cap");
-  const profHoist = `${i}const ${pmV} = _ctx._pmProfile, ${recV} = ${pmV}?.phase === 'recognizer', ${capV} = ${pmV}?.phase === 'capture'`;
-  const profileRecognizer = recV;
-  const profileCapture = capV;
-  const cstMode = ctx.hostMode === "cst";
-  const directCstV = !structural && !cstMode && (!capturesChildren || !capturesRaw) ? v(ctx, "_dcst") : null;
-  const directCstGate = directCstV === null ? "false" : profileCapture;
+  const profileRecognizer = "false";
+  const profileCapture = "false";
   const structuralCapturesTrivia = structural && (def.captureTrivia === true || def.trailingTrivia === true);
   const chNeededExpr = def.unwrap || def.collapse ? "true" : `(_ctx._pmReadsCh ??= (_ctx.build === undefined || _ctx.build._parsemanReadsChildren !== false || _ctx.build._parsemanCstCollapse !== undefined))`;
-  const chAlloc = def.unwrap || def.collapse ? `${profileRecognizer} ? undefined : []` : `${profileRecognizer} ? undefined : ((${profileCapture} || ${chNeededExpr}) ? [] : undefined)`;
-  const allocStmt = structural ? `${i}const ${capTLv} = !(${profileRecognizer}) && (${profileCapture} || ${structuralCapturesTrivia ? "true" : hostTriviaGate}), ${capSTv} = !(${profileRecognizer} || ${profileCapture}) && (_ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6)))${capFv ? `, ${capFv} = !(${profileRecognizer}) && (${profileCapture} || (_ctx.build !== undefined && _hostReads(_ctx.build, 2)))` : ""}
-${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [], ${tlV} = ${profileRecognizer} ? undefined : ${innerEnablesTriviaCapture ? "[]" : `${capTLv} ? [] : _EMPTY_TL`}` : capturesTrivia ? `${directCstV ? `${i}const ${directCstV} = ${directCstGate}
-` : ""}${i}const ${capTLv} = !(${profileRecognizer}), ${chV} = ${profileRecognizer} ? undefined : ${capturesChildren ? "[]" : `${directCstV} ? [] : undefined`}, ${rawV} = ${profileRecognizer} ? undefined : ${capturesRaw ? "[]" : `${directCstV} ? [] : undefined`}, ${tlV} = ${profileRecognizer} ? undefined : []` : `${directCstV ? `${i}const ${directCstV} = ${directCstGate}
-` : ""}${i}const ${chV} = ${profileRecognizer} ? undefined : ${capturesChildren ? "[]" : `${directCstV} ? [] : undefined`}, ${rawV} = ${profileRecognizer} ? undefined : ${capturesRaw ? "[]" : `${directCstV} ? [] : undefined`}`;
+  const chAlloc = def.unwrap || def.collapse ? tern(profileRecognizer, "undefined", "[]") : tern(profileRecognizer, "undefined", `${tern(orGate(profileCapture, chNeededExpr), "[]", "undefined")}`);
+  const dcstAlloc = "undefined";
+  const allocStmt = structural ? `${i}const ${capTLv} = ${andGate(notGate(profileRecognizer), orGate(profileCapture, structuralCapturesTrivia ? "true" : hostTriviaGate))}, ${capSTv} = ${andGate(notGate(orGate(profileRecognizer, profileCapture)), "(_ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 6)))")}${capFv ? `, ${capFv} = ${andGate(notGate(profileRecognizer), orGate(profileCapture, "(_ctx.build !== undefined && _hostReads(_ctx.build, 2))"))}` : ""}
+${i}const ${chV} = ${chAlloc}, ${rawV} = ${tern(profileRecognizer, "undefined", "[]")}, ${tlV} = ${tern(profileRecognizer, "undefined", innerEnablesTriviaCapture ? "[]" : `${capTLv} ? [] : _EMPTY_TL`)}` : capturesTrivia ? `${i}const ${capTLv} = ${notGate(profileRecognizer)}, ${chV} = ${tern(profileRecognizer, "undefined", capturesChildren ? "[]" : dcstAlloc)}, ${rawV} = ${tern(profileRecognizer, "undefined", capturesRaw ? "[]" : dcstAlloc)}, ${tlV} = ${tern(profileRecognizer, "undefined", "[]")}` : `${i}const ${chV} = ${tern(profileRecognizer, "undefined", capturesChildren ? "[]" : dcstAlloc)}, ${rawV} = ${tern(profileRecognizer, "undefined", capturesRaw ? "[]" : dcstAlloc)}`;
   const innerTl = structural || capturesTrivia ? structural && !innerEnablesTriviaCapture ? `${capTLv} ? ${tlV} : undefined` : tlV : "undefined";
-  const fieldsOn = structural ? capFv ?? "false" : `${profileRecognizer} ? false : ${capturesFields ? "true" : "false"}`;
+  const fieldsOn = structural ? capFv ?? "false" : tern(profileRecognizer, "false", capturesFields ? "true" : "false");
   const sf = hasFields ? v(ctx, "_sf") : null;
   const fArr = hasFields ? v(ctx, "_fa") : null;
   const fObj = hasFields ? v(ctx, "_fields") : "undefined";
@@ -9471,7 +9826,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   const installTrivia = needsTriviaFrame ? `; _ctx.captureTrivia = ${capTLv ?? "false"}; _ctx._cstTriviaLog = ${innerTl}${smk ? `; _ctx._triviaCaptureMask = ${capTLv} && _ctx.build !== undefined && _ctx.build._parsemanTriviaKinds !== undefined ? _ctx.build._parsemanTriviaKinds(${JSON.stringify(def.type)}) : ${smk}` : ""}` : "";
   const restoreTrivia = needsTriviaFrame ? `; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}${smk ? `; _ctx._triviaCaptureMask = ${smk}` : ""}` : "";
   const preGuard = [];
-  if (!ctx.recovery && !ctx.coverage && (capturesChildren || structural) && needsFirstSetGuard(def.parser)) {
+  if (!ctx.recovery && !ctx.coverage && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_ngc");
     const gExp = armStaticExpected(ctx, def.parser);
     const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(ctx, gExp, pos);
@@ -9482,7 +9837,6 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   }
   const stmts = [
     ...preGuard,
-    profHoist,
     allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren${saveTrivia}${sf ? `, ${sf} = _ctx._fields` : ""}`,
     `${i}_ctx._cstChildren = ${chV}; _ctx._cstLeaves = ${chV}; _ctx._cstRawChildren = ${rawV}${installTrivia}${sf ? `; _ctx._fields = ${fieldsOn} ? [] : undefined` : ""}`
@@ -9499,21 +9853,13 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   }
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}${restoreTrivia}${sf ? `; _ctx._fields = ${sf}` : ""}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
-  stmts.push(
-    `${i}if (_ctx._pmProfile) {`,
-    `${i}  _ctx._pmProfile.nodes++`,
-    `${i}  if (${profileCapture}) {`,
-    `${i}    _ctx._pmProfile.childSlots += ${chV}.length; _ctx._pmProfile.rawSlots += ${rawV}.length; _ctx._pmProfile.triviaSlots += ${tlV}.length${fArr ? `; _ctx._pmProfile.fieldSlots += ${fArr} ? ${fArr}.length : 0` : ""}`,
-    `${i}  }`,
-    `${i}}`
-  );
   let stV = "undefined";
   if (structural) {
     stV = v(ctx, "_nst");
     stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   } else if (clonesState) {
     stV = v(ctx, "_nst");
-    stmts.push(`${i}const ${stV} = !(${profileRecognizer} || ${profileCapture}) && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+    stmts.push(`${i}const ${stV} = ${andGate(notGate(orGate(profileRecognizer, profileCapture)), "_ctx.state !== undefined")} ? Object.assign({}, _ctx.state) : undefined`);
   }
   if (sf && fArr) {
     const fe = v(ctx, "_fe");
@@ -9537,19 +9883,22 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   if (ctx.lineTracking) stmts.push(`${i}const ${nodeSpanV} = ${nodeSpanExpr}`);
   const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: ${nodeSpanV}, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, nodeSpanV, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
   const hostBuildArgs = `${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV}${def.tags !== void 0 && def.tags.length > 0 ? `, ${JSON.stringify(def.tags)}` : ""}`;
-  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${hostBuildArgs})`;
+  const hostBuildExpr = `_ctx.build(${hostBuildArgs})`;
   const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : cstOut ? hostBuildExpr : buildExpr;
-  const hostCollapseExpr = structural ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
+  const hostCollapses = structural || cstOut;
+  const hostCollapseExpr = hostCollapses ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
   const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
   const collapseExpr = `${chV}.length === 1 ? ${chV}[0] : (${ndExpr})`;
   const finalExpr = def.unwrap ? unwrapExpr : def.collapse ? collapseExpr : hostCollapseExpr;
-  stmts.push(
-    `${i}const ${ndV} = (${profileRecognizer} || ${profileCapture}) ? undefined : (${finalExpr})`,
-    `${i}if (!(${profileRecognizer})) {`,
-    `${i}  if (${sc}) ${sc}.push(${ndV})`,
-    `${i}  if (${sr}) ${sr}.push((typeof ${ndV} === 'object' && ${ndV} !== null && (${ndV}._tag === 'node' || ${ndV}._tag === 'leaf' || ${ndV}._tag === 'parseError')) ? ${ndV} : { _tag: 'leaf', value: typeof ${ndV} === 'string' ? ${ndV} : (typeof ${ndV} === 'object' && ${ndV} !== null ? input.slice(${pos}, ${endVar}) : ''), span: ${nodeSpanV} })`,
-    `${i}}`
-  );
+  const ndGate = orGate(profileRecognizer, profileCapture);
+  const recGate = notGate(profileRecognizer);
+  const pushIndent = recGate === "true" ? i : `${i}  `;
+  const pushCh = `${pushIndent}if (${sc}) ${sc}.push(${ndV})`;
+  ctx.needsRawEntry = true;
+  const pushRaw = `${pushIndent}if (${sr}) ${sr}.push(_rawEntry(${ndV}, input, ${pos}, ${endVar}${ctx.lineTracking ? `, ${nodeSpanV}` : ""}))`;
+  stmts.push(`${i}const ${ndV} = ${tern(ndGate, "undefined", `(${finalExpr})`)}`);
+  if (recGate === "true") stmts.push(pushCh, pushRaw);
+  else stmts.push(`${i}if (${recGate}) {`, pushCh, pushRaw, `${i}}`);
   return { stmts, valueVar: ndV, endVar };
 }
 function emitRuntimeFallback(parser2, ctx, pos) {
@@ -9578,7 +9927,12 @@ function emitLazy(p, def, ctx, pos) {
     } catch {
       return emitRuntimeFallback(p, ctx, pos);
     }
-    return emit(resolved, ctx, pos);
+    const cost = usage.sizes.get(resolved) ?? 1;
+    if (cost <= ctx.inlineLeft) {
+      ctx.inlineLeft -= cost;
+      return emit(resolved, ctx, pos);
+    }
+    _inlineCapSink?.push({ fn: ctx.currentFnName ?? "<root>", nodes: cost });
   }
   if (!ctx.namedParsers.has(p)) {
     const fnName2 = canonical2 ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
@@ -9593,6 +9947,9 @@ function emitLazy(p, def, ctx, pos) {
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
     const savedRecord = ctx.recordFail;
+    const savedInlineLeft = ctx.inlineLeft, savedFnName = ctx.currentFnName;
+    ctx.inlineLeft = ctx.inlineMax;
+    ctx.currentFnName = fnName2;
     const failureRuleId = p === ctx.coverage?.entry ? void 0 : ctx.coverage?.plan.rules.get(p) ?? ctx.coverage?.plan.rules.get(resolved);
     const savedActiveRule = ctx.activeCoverageRuleId;
     const savedSuppressFailure = ctx.suppressCoverageFailure;
@@ -9607,6 +9964,8 @@ function emitLazy(p, def, ctx, pos) {
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
     ctx.recordFail = savedRecord;
+    ctx.inlineLeft = savedInlineLeft;
+    ctx.currentFnName = savedFnName;
     ctx.activeCoverageRuleId = savedActiveRule;
     ctx.suppressCoverageFailure = savedSuppressFailure;
     pushNamedFnDecl(ctx, fnName2, r.stmts, r.valueVar, r.endVar, failureRuleId);
@@ -9701,6 +10060,9 @@ function emit(p, ctx, pos) {
     const savedIndent = ctx.indent;
     const savedFailLabel = ctx.failLabel;
     const savedRecord = ctx.recordFail;
+    const savedInlineLeft = ctx.inlineLeft, savedFnName = ctx.currentFnName;
+    ctx.inlineLeft = ctx.inlineMax;
+    ctx.currentFnName = fnName;
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
     ctx.recordFail = true;
@@ -9708,6 +10070,8 @@ function emit(p, ctx, pos) {
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
     ctx.recordFail = savedRecord;
+    ctx.inlineLeft = savedInlineLeft;
+    ctx.currentFnName = savedFnName;
     pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar);
     return instrument(emitNamedFnCall(ctx, fnName, pos));
   }
@@ -9901,7 +10265,7 @@ function emitDispatch(p, ctx, pos) {
     case "peek":
       return emitPeek(def, ctx, pos);
     case "routed":
-      return emitRouted(ctx, pos);
+      return emitRouted(ctx, pos, def);
     case "node":
       return emitNode(def, ctx, pos);
     case "scanTo":
@@ -9936,6 +10300,9 @@ function emitDispatch(p, ctx, pos) {
         const savedIndent = ctx.indent;
         const savedFailLabel = ctx.failLabel;
         const savedRecord = ctx.recordFail;
+        const savedInlineLeft = ctx.inlineLeft, savedFnName = ctx.currentFnName;
+        ctx.inlineLeft = ctx.inlineMax;
+        ctx.currentFnName = fnName;
         ctx.indent = 1;
         ctx.failLabel = "_pfail";
         ctx.recordFail = true;
@@ -9943,6 +10310,8 @@ function emitDispatch(p, ctx, pos) {
         ctx.indent = savedIndent;
         ctx.failLabel = savedFailLabel;
         ctx.recordFail = savedRecord;
+        ctx.inlineLeft = savedInlineLeft;
+        ctx.currentFnName = savedFnName;
         pushNamedFnDecl(ctx, fnName, innerR.stmts, innerR.valueVar, innerR.endVar);
       }
       const fn = ctx.namedParsers.get(innerParser);
@@ -10101,12 +10470,16 @@ function childrenOf3(def) {
       return [def.parser, def.sentinel];
     case "scanTo":
       return [def.sentinel, ...def.skip];
+    // A `routed()` fallback IS emitted at this site (emitRouted), so the usage
+    // analysis must see the edge — otherwise a fallback shared by several routed()
+    // sites is miscounted as single-use and inlined at each.
+    case "routed":
+      return def.fallback ? [def.fallback] : [];
     case "lazy":
     case "literal":
     case "regex":
     case "keywords":
     case "guard":
-    case "routed":
     case "unknown":
       return [];
   }
@@ -10127,6 +10500,17 @@ function isHoistableTag(tag) {
   return HOISTABLE_TAGS.has(tag);
 }
 var HOIST_MIN_SUBTREE = 3;
+var INLINE_MAX_NODES = 1e3;
+function resolveInlineMax(explicit) {
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_MAX_INLINE : void 0;
+  if (env !== void 0 && env !== "") {
+    if (env === "off" || env === "infinity") return Infinity;
+    const n = Number(env);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return INLINE_MAX_NODES;
+}
 function analyzeLazyUsage(root) {
   return analyzeLazyUsageMulti([root]);
 }
@@ -10232,102 +10616,6 @@ function ruleDependencies(ruleMap) {
   }
   return deps;
 }
-function resolveGatingLevel(opt) {
-  const explicit = typeof opt === "string" ? opt : opt?.level;
-  if (explicit !== void 0) return explicit;
-  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_GATING : void 0;
-  if (env === "off" || env === "warn" || env === "error") return env;
-  return "warn";
-}
-function runGatingDiagnostic(combinator, opt) {
-  return reportGating(opt, (o) => analyzeGating(combinator, o));
-}
-function runGatingDiagnosticRules(ruleMap, opt) {
-  return reportGating(opt, (o) => analyzeGatingRules(ruleMap, o));
-}
-function runFusedGatingDiagnostic(getRuleMaps, opt, getOpaque) {
-  if (resolveGatingLevel(opt) === "off") return void 0;
-  const ruleMaps = getRuleMaps();
-  const opaque = getOpaque?.() ?? [];
-  const opaqueFindings = opaque.map((o) => ({
-    rule: o.ruleNames.length > 0 ? o.ruleNames.join(", ") : `<artifact ${o.ns}>`,
-    kind: "opaque-artifact",
-    reason: `precompiled artifact "${o.ns}" carries compiled rule functions, not re-lowerable IR \u2014 its choices were not examined at this fuse.`
-  }));
-  if (!ruleMaps.some((map) => hasExternalRuleRef(map))) {
-    if (opaqueFindings.length === 0) return void 0;
-    return reportGating(opt, () => ({
-      totalChoices: 0,
-      gated: 0,
-      recoverable: 0,
-      unanalysable: opaqueFindings,
-      ungated: [],
-      accepted: [],
-      deferred: [],
-      acceptedUnused: [],
-      choices: [],
-      antiPatterns: []
-    }));
-  }
-  const winners = /* @__PURE__ */ new Map();
-  for (const map of ruleMaps) for (const [name, rule] of map) {
-    if (rule._def.tag === "lazy") {
-      try {
-        rule._def.thunk();
-      } catch {
-        continue;
-      }
-    }
-    winners.set(name, rule);
-  }
-  const entries = [...winners];
-  return reportGating(opt, (o) => {
-    const deferredHere = new Set(analyzeGatingRules(entries, o).deferred.map((c) => c.id));
-    const fused = analyzeGatingRules(entries, { ...o, resolveRef: (name) => winners.get(name) });
-    return {
-      ...fused,
-      ungated: fused.ungated.filter((c) => deferredHere.has(c.id)),
-      antiPatterns: [],
-      unanalysable: [...fused.unanalysable, ...opaqueFindings]
-    };
-  });
-}
-function reportGating(opt, analyze) {
-  const level = resolveGatingLevel(opt);
-  if (level === "off") return void 0;
-  const obj = opt !== null && typeof opt === "object" ? opt : void 0;
-  const analyzeOpts = obj?.accept !== void 0 || obj?.entryName !== void 0 ? { ...obj.accept !== void 0 ? { accept: obj.accept } : {}, ...obj.entryName !== void 0 ? { entryName: obj.entryName } : {} } : void 0;
-  let report;
-  try {
-    report = analyze(analyzeOpts);
-  } catch (e) {
-    const reason = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
-    const failed = {
-      totalChoices: 0,
-      gated: 0,
-      recoverable: 0,
-      unanalysable: [{ rule: "<whole grammar>", kind: "not-a-combinator", reason: `gating analysis threw \u2014 ${reason}` }],
-      ungated: [],
-      accepted: [],
-      deferred: [],
-      acceptedUnused: [],
-      choices: [],
-      antiPatterns: []
-    };
-    const failLines = formatGatingWarnings(failed);
-    if (level === "error") throw new Error(`parseman: gating analysis FAILED (no verdict available)
-${failLines.join("\n")}`);
-    for (const l of failLines) console.warn(l);
-    return failed;
-  }
-  const lines = formatGatingWarnings(report);
-  if (lines.length > 0) {
-    if (level === "error") throw new Error(`parseman: ${report.ungated.length} ungated hot choice(s) / ${report.antiPatterns.length} anti-pattern(s) / ${report.unanalysable.length} unanalysable rule(s)
-${lines.join("\n")}`);
-    for (const l of lines) console.warn(l);
-  }
-  return report;
-}
 function resolveDuplicationLevel(opt) {
   const explicit = typeof opt === "string" ? opt : opt?.level;
   if (explicit !== void 0) return explicit;
@@ -10370,7 +10658,17 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 function compile(combinator, mapFnSources, opts) {
-  const gatingReport = runGatingDiagnostic(combinator, opts?.gating);
+  const drain = beginCompileDegradationDrain();
+  let completed = false;
+  try {
+    const compiled = compileImpl(combinator, mapFnSources, opts);
+    completed = true;
+    return compiled;
+  } finally {
+    drain(completed);
+  }
+}
+function compileImpl(combinator, mapFnSources, opts) {
   runDuplicationDiagnostic(combinator, opts?.duplication);
   markUnusedValues(combinator);
   const grammarTrivia = combinator._meta.grammarTrivia;
@@ -10378,9 +10676,12 @@ function compile(combinator, mapFnSources, opts) {
   const grammarScanSkip = combinator._meta.grammarScanSkip;
   const grammarHostMode = combinator._meta.grammarHostMode;
   const grammarTrackLines = combinator._meta.grammarTrackLines;
+  const _inlineMax = resolveInlineMax(opts?.maxInline);
   const ctx = {
     vars: 0,
     indent: 1,
+    inlineMax: _inlineMax,
+    inlineLeft: _inlineMax,
     regexDecls: [],
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
@@ -10426,11 +10727,13 @@ function compile(combinator, mapFnSources, opts) {
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
   const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
+  const rawEntryDecls = ctx.needsRawEntry ? [RAW_ENTRY_DECL] : [];
   const lineTrackDecls = ctx.needsLineTrack ? [LINE_TRACK_DECL] : [];
   const lineSpanDecls = ctx.needsLineSpan ? [LINE_SPAN_DECL] : [];
   const source = [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...rawEntryDecls,
     ...lineTrackDecls,
     ...lineSpanDecls,
     ...ctx.regexDecls,
@@ -10445,6 +10748,7 @@ function compile(combinator, mapFnSources, opts) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...rawEntryDecls,
     ...lineTrackDecls,
     ...lineSpanDecls,
     ...ctx.regexDecls,
@@ -10494,8 +10798,7 @@ function compile(combinator, mapFnSources, opts) {
   const compiledMeta = {
     source,
     inlineExpression,
-    ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions },
-    ...gatingReport === void 0 ? {} : { gating: gatingReport }
+    ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions }
   };
   if (!ctx.lineTracking) {
     return {
@@ -10561,7 +10864,6 @@ function publicRuleWrapperSource(rule, fnSource, ambientTriviaKindLabels, ambien
 }
 function compileLinkable(ruleMapArg, ns, opts) {
   if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
-  if (opts?.gating !== void 0) runGatingDiagnosticRules(ruleMapArg, opts.gating);
   if (opts?.duplication !== void 0) runDuplicationDiagnosticRules(ruleMapArg, opts.duplication);
   for (const [, rule] of ruleMapArg) markUnusedValues(rule);
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
@@ -10580,9 +10882,12 @@ function compileLinkable(ruleMapArg, ns, opts) {
     }
   });
   const nodeMeta = new Map(ruleMap.map(([name, rule]) => [name, collectGrammarReflection([[name, rule]], { followLazy: false })]));
+  const _inlineMax = resolveInlineMax(opts?.maxInline);
   const ctx = {
     vars: 0,
     indent: 1,
+    inlineMax: _inlineMax,
+    inlineLeft: _inlineMax,
     regexDecls: [],
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
@@ -10678,6 +10983,9 @@ function compileLinkable(ruleMapArg, ns, opts) {
         }
       }
       const savedIndent = ctx.indent, savedFail = ctx.failLabel, savedRec = ctx.recordFail;
+      const savedInlineLeft = ctx.inlineLeft, savedFnName = ctx.currentFnName;
+      ctx.inlineLeft = ctx.inlineMax;
+      ctx.currentFnName = fn;
       ctx.indent = 1;
       ctx.failLabel = "_pfail";
       ctx.recordFail = true;
@@ -10693,6 +11001,8 @@ function compileLinkable(ruleMapArg, ns, opts) {
       ctx.indent = savedIndent;
       ctx.failLabel = savedFail;
       ctx.recordFail = savedRec;
+      ctx.inlineLeft = savedInlineLeft;
+      ctx.currentFnName = savedFnName;
       const ruleId = ctx.coverage?.plan.rules.get(rule);
       const stmts = ruleId === void 0 ? body.stmts : [
         `${ind(ctx)}_ctx._grammarCoverage?.(${JSON.stringify(ruleId)})`,
@@ -10777,6 +11087,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
     needsHostReads: !!ctx.needsHostReads,
+    needsRawEntry: !!ctx.needsRawEntry,
     hostMode: ctx.hostMode ?? "ast",
     hostBranchElided: !!ctx.hostBranchElided,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
@@ -10786,26 +11097,6 @@ function compileLinkable(ruleMapArg, ns, opts) {
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function hasExternalRuleRef(ruleMap) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (p) => {
-    if (seen.has(p)) return false;
-    seen.add(p);
-    const def = p._def;
-    if (def.tag === "lazy") {
-      let resolved;
-      try {
-        resolved = def.thunk();
-      } catch {
-        resolved = void 0;
-      }
-      if (resolved === void 0) return p._ruleName !== void 0;
-      return visit(resolved);
-    }
-    return childrenOf3(def).some(visit);
-  };
-  return ruleMap.some(([, rule]) => visit(rule));
-}
 function hasSemanticReduction(roots, externalRefs) {
   const seen = /* @__PURE__ */ new Set();
   const visit = (parser2) => {
@@ -10851,14 +11142,16 @@ function buildInlineExpression(ctx, r, mapFnSources, buildSources, coverageRootR
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
   const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "";
+  const rawEntryDecl = ctx.needsRawEntry ? `  ${RAW_ENTRY_DECL}` : "";
   const lineTrackDecl = ctx.needsLineTrack ? `  ${LINE_TRACK_DECL}` : "";
   const lineSpanDecl = ctx.needsLineSpan ? `  ${LINE_SPAN_DECL}` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl || !!lineTrackDecl || !!lineSpanDecl;
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl || !!rawEntryDecl || !!lineTrackDecl || !!lineSpanDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
     hostReadsDecl,
+    rawEntryDecl,
     lineTrackDecl,
     lineSpanDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
@@ -10928,11 +11221,12 @@ function childrenOf4(def) {
       return [def.main, def.skipped];
     case "scanTo":
       return [def.sentinel, ...def.skip];
+    case "routed":
+      return def.fallback ? [def.fallback] : [];
     case "lazy":
     case "literal":
     case "regex":
     case "keywords":
-    case "routed":
     case "guard":
     case "recover":
     case "unknown":
@@ -11014,7 +11308,7 @@ function evalRuleMapIR(ir) {
     l._def.fnSrc = src;
     return l;
   };
-  const _nd = (type, child, src, opts, staticError) => {
+  const _nd = (type, child, src, opts, staticError, sigSrc) => {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
     }
@@ -11023,6 +11317,7 @@ function evalRuleMapIR(ir) {
     }), opts);
     n._def.buildSrc = src;
     if (staticError !== void 0) n._def.buildStaticError = staticError;
+    if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
     return n;
   };
   const _gch = (items) => {
@@ -11335,7 +11630,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "peek":
         return `peek(${kid(def.parser)})`;
       case "routed":
-        return "routed()";
+        return def.fallback === void 0 ? "routed()" : `routed(${kid(def.fallback)})`;
       case "trivia":
         return `trivia(${kid(def.parser)})`;
       case "token":
@@ -11368,6 +11663,9 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
           ...projectEntry === void 0 ? [] : [projectEntry],
           ...def.captureTrivia ? ["captureTrivia: true"] : [],
           ...def.trailingTrivia ? ["trailingTrivia: true"] : [],
+          // Declared or resolved arity. Carried so a re-lowered composed artifact does
+          // not silently re-acquire the fail-open capture cost this module resolved away.
+          ...def.buildArity === void 0 ? [] : [`buildArity: ${def.buildArity}`],
           ...tagEntry === void 0 ? [] : [tagEntry]
         ];
         const opts = optEntries.length > 0 ? `, { ${optEntries.join(", ")} }` : "";
@@ -11376,8 +11674,14 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
           return opts ? `node(${kid(def.parser)}, undefined${opts})` : `node(${kid(def.parser)})`;
         }
         if (def.buildSrc !== void 0) {
-          const staticError = def.buildStaticError === void 0 ? "" : `${opts ? "" : ", undefined"}, ${JSON.stringify(def.buildStaticError)}`;
-          return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts}${staticError})`;
+          const tail = [];
+          if (def.buildStaticError !== void 0 || def.buildSigSrc !== void 0) {
+            if (!opts) tail.push("undefined");
+            tail.push(def.buildStaticError === void 0 ? "undefined" : JSON.stringify(def.buildStaticError));
+          }
+          if (def.buildSigSrc !== void 0) tail.push(JSON.stringify(def.buildSigSrc));
+          const trailing = tail.length > 0 ? `, ${tail.join(", ")}` : "";
+          return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts}${trailing})`;
         }
         return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`;
       }
@@ -11434,7 +11738,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(
@@ -11458,12 +11762,14 @@ function fusedBody(pieces) {
   const contributingPieces = [...contributing];
   const needsEmptyTl = contributingPieces.some((p) => p.needsEmptyTl);
   const needsHostReads = contributingPieces.some((p) => p.needsHostReads);
+  const needsRawEntry = contributingPieces.some((p) => p.needsRawEntry);
   const lines = [
     // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
     "const _pfFail = {}",
     "let _pfEnd",
     ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
     ...needsHostReads ? [HOST_READS_DECL] : [],
+    ...needsRawEntry ? [RAW_ENTRY_DECL] : [],
     // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
     ...new Set(contributingPieces.flatMap((p) => p.prelude)),
     // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
@@ -11472,8 +11778,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"),
     "}",
@@ -11489,6 +11794,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();
@@ -11529,7 +11835,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.
@@ -11540,6 +11846,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;
@@ -11579,17 +11886,6 @@ var COMPOSED_COVERAGE_RULES = /* @__PURE__ */ Symbol.for("parseman.composedCover
 function isIRPiece(p) {
   return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
 }
-function once(fn) {
-  let done = false;
-  let value;
-  return () => {
-    if (!done) {
-      value = fn();
-      done = true;
-    }
-    return value;
-  };
-}
 function carriedRuleMapsDetailed(carried) {
   const maps = [];
   const opaque = [];
@@ -11706,12 +12002,6 @@ function compose(items, opts) {
   const used = /* @__PURE__ */ new Set();
   const trivia2 = composingTriviaOf(items);
   const carried = items.flatMap((item) => itemCarried(item, used, trivia2, opts?.hostMode));
-  const detailed = once(() => carriedRuleMapsDetailed(carried));
-  runFusedGatingDiagnostic(
-    () => detailed().maps,
-    void 0,
-    () => detailed().opaque
-  );
   const pieces = carried.map((p) => materializePiece(p, trivia2, false, opts?.hostMode));
   const map = fuseRules(pieces);
   Object.defineProperty(map, COMPOSED_PIECES, { value: carried, enumerable: false });
@@ -11720,8 +12010,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
@@ -11738,14 +12188,1123 @@ function analyzeGrammarGating(grammar, opts) {
     kind: "opaque-artifact",
     reason: `precompiled artifact "${o.ns}" carries compiled rule functions, not re-lowerable IR \u2014 its choices cannot be examined. Recompile the contributing grammar so it carries IR (the macro emits IR by default) to bring it back into analysis.`
   }));
+  for (const o of opaque) {
+    recordDegradation({
+      code: "opaque-artifact",
+      // `info`, not `warn`: the artifact is usually someone else's package, so the author
+      // of THIS grammar has nothing to act on — but the blind spot still has to be counted.
+      severity: "info",
+      where: o.ruleNames.length > 0 ? o.ruleNames.join(", ") : `<artifact ${o.ns}>`,
+      subject: `precompiled artifact "${o.ns}"`,
+      fellBackTo: `it carries compiled rule functions rather than re-lowerable IR, so its ${o.ruleNames.length > 0 ? `${o.ruleNames.length} rule(s)` : "rules"} were NOT analysed and a clean gating report must not be read as a pass`,
+      otherwise: "its choices would be walked like any other rule. Recompile the contributing grammar so it carries IR (the macro emits IR by default)"
+    });
+  }
   return fromOpaque.length === 0 ? report : { ...report, unanalysable: [...report.unanalysable, ...fromOpaque] };
 }
 
-// src/combinators/gate.ts
-function gate(predicate) {
-  const meta = {
-    firstSet: { kind: "any" },
-    canMatchNewline: false,
+// src/analysis/diagnose.ts
+var isCombinator = (g) => typeof g === "object" && g !== null && "_def" in g;
+var isRuleEntries = (g) => Array.isArray(g);
+function diagnoseGrammar(grammar, opts) {
+  const depth = degradationCaptureDepth();
+  beginDegradationCapture();
+  let report;
+  let degradations;
+  try {
+    report = runAnalysis(grammar, opts);
+  } catch (e) {
+    const reason = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+    report = emptyReport(`gating analysis threw \u2014 ${reason}`);
+  } finally {
+    degradations = unwindDegradationCapture(depth);
+  }
+  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(
+    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 && !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.`
+    );
+  }
+  for (const f of d.findings) {
+    lines.push(`${f.severity === "blocking" ? "\u2717" : "\xB7"} [${f.code}] ${f.id}: ${f.message}`);
+    for (const detail of f.details) lines.push(`    ${detail.replace(/\n/g, "\n    ")}`);
+    if (f.acceptKey !== void 0) {
+      lines.push(`    intentional? add to the gating snapshot: { accept: ['${f.acceptKey}'] }`);
+    }
+  }
+  if (!d.ok && d.acceptSnapshot.length > 0) {
+    lines.push(`  accept-all snapshot: { accept: [${d.acceptSnapshot.map((i) => `'${i}'`).join(", ")}] }`);
+  }
+  return lines;
+}
+function runAnalysis(grammar, opts) {
+  if (isCombinator(grammar)) return analyzeGating(grammar, opts);
+  if (isRuleEntries(grammar)) return analyzeGatingRules(grammar, opts);
+  return analyzeGrammarGating(grammar, opts);
+}
+function emptyReport(reason) {
+  return {
+    totalChoices: 0,
+    gated: 0,
+    recoverable: 0,
+    unanalysable: [{ rule: "<whole grammar>", kind: "not-a-combinator", reason }],
+    ungated: [],
+    accepted: [],
+    deferred: [],
+    acceptedUnused: [],
+    choices: [],
+    antiPatterns: []
+  };
+}
+var blockingOf = (d) => d.findings.filter((f) => f.severity === "blocking");
+var SEVERITY_RANK = { blocking: 0, advisory: 1 };
+var CODE_RANK = {
+  unanalysable: 0,
+  "ungated-choice": 1,
+  "anti-pattern": 2,
+  degraded: 3,
+  "stale-accept": 4
+};
+function assemble(report, degradations) {
+  const findings = [];
+  for (const u of report.unanalysable) {
+    findings.push({
+      id: u.rule,
+      code: "unanalysable",
+      severity: "blocking",
+      rule: u.rule,
+      message: `could not be examined [${u.kind}] \u2014 no verdict about it is available`,
+      details: [u.reason]
+    });
+  }
+  for (const c of report.ungated) {
+    findings.push({
+      id: c.id,
+      code: "ungated-choice",
+      severity: "blocking",
+      rule: c.rule,
+      message: `choice is UNGATED [${c.strategy}] \u2014 no first-char dispatch; every position speculatively enters doomed arms`,
+      details: [
+        ...c.anyArms.map((a) => `arm[${a.index}] first-set ANY (${a.cause}): ${a.detail}
+fix: ${a.suggestion}`),
+        ...c.overlaps.map((o) => `arm[${o.a}] \u2229 arm[${o.b}] overlap on ${firstSetToString(o.on)}
+fix: ${o.suggestion}`)
+      ],
+      acceptKey: c.id
+    });
+  }
+  for (const ap of report.antiPatterns) {
+    findings.push({
+      id: `${ap.rule}#arm${ap.armIndex}`,
+      code: "anti-pattern",
+      severity: "blocking",
+      rule: ap.rule,
+      message: `[${ap.kind}] ${ap.message}`,
+      details: []
+    });
+  }
+  for (const d of degradations) {
+    findings.push({
+      // `where` + `code` is the degradation channel's own identity; reuse it so the two
+      // surfaces name the same thing the same way.
+      id: `${d.code}@${d.where}`,
+      code: "degraded",
+      // Mirrors `DegradationSeverity`: 'warn' is a real cost the author can remove,
+      // 'info' is a fact they cannot act on (someone else's package).
+      severity: d.severity === "warn" ? "blocking" : "advisory",
+      rule: d.where,
+      message: formatDegradation(d),
+      details: []
+    });
+  }
+  for (const id of report.acceptedUnused) {
+    findings.push({
+      id,
+      code: "stale-accept",
+      severity: "advisory",
+      rule: id,
+      message: "accept entry matched no ungated choice \u2014 the grammar was fixed; prune this line",
+      details: []
+    });
+  }
+  findings.sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] || CODE_RANK[a.code] - CODE_RANK[b.code] || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  return {
+    schema: "parseman.diagnosis/1",
+    ok: !findings.some((f) => f.severity === "blocking"),
+    summary: {
+      totalChoices: report.totalChoices,
+      gated: report.gated,
+      recoverable: report.recoverable,
+      ungated: report.ungated.length,
+      accepted: report.accepted.length,
+      deferred: report.deferred.length,
+      antiPatterns: report.antiPatterns.length,
+      unanalysable: report.unanalysable.length,
+      degraded: degradations.length,
+      staleAccepts: report.acceptedUnused.length
+    },
+    findings,
+    acceptSnapshot: report.ungated.map((c) => c.id).sort(),
+    gating: report,
+    degradations
+  };
+}
+
+// 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/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 {
@@ -11760,9 +13319,6 @@ function gate(predicate) {
   };
 }
 
-// src/combinators/guard.ts
-var guard = gate;
-
 // src/combinators/completions.ts
 function completionsAt(target, input, offset, options = {}) {
   const probe = { offset, best: null };
@@ -11989,9 +13545,9 @@ function parseMiddle(input, reStart, reEnd, cStart, ruleFn, separator, build, to
   const ctx = mkCtx(null, build, tolerant);
   const out = [];
   let pos = reStart;
-  let guard2 = 0;
+  let guard = 0;
   while (pos < reEnd) {
-    if (++guard2 > reEnd - reStart + 2) return null;
+    if (++guard > reEnd - reStart + 2) return null;
     if (separator && out.length > 0 && out[out.length - 1]._tag === "node") {
       if (pos + separator.length > reEnd || !input.startsWith(separator, pos)) return null;
       out.push({ _tag: "leaf", value: separator, span: { start: pos - cStart, end: pos + separator.length - cStart } });
@@ -12283,142 +13839,6 @@ function parseDoc(registry, rootRule, input, opts = {}) {
   return new ParseDocImpl(registry, rootRule, opts, { abs: null }, [fail], null, input);
 }
 
-// src/functional/run.ts
-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 clonePassState(state) {
-  if (state === null || typeof state !== "object") return state;
-  return Array.isArray(state) ? [...state] : { ...state };
-}
-function profilePass(entry, input, options, phase) {
-  const state = { phase, nodes: 0, childSlots: 0, rawSlots: 0, triviaSlots: 0, fieldSlots: 0, hostCalls: 0 };
-  const passOptions = options.state === void 0 ? options : { ...options, state: clonePassState(options.state) };
-  const start = performance.now();
-  const result = runOnce(entry, input, passOptions, phase, state);
-  const { phase: _phase, ...counts } = state;
-  return { result, profile: { ms: performance.now() - start, ...counts } };
-}
-function run(entry, input, options = {}) {
-  if (!options.profile) return runOnce(entry, input, options);
-  if (typeof entry !== "function") {
-    throw new TypeError("run({ profile: true }) requires a compiled parser entry");
-  }
-  const recognizer = profilePass(entry, input, options, "recognizer");
-  const capture = profilePass(entry, input, options, "capture");
-  const host = profilePass(entry, input, options, "host");
-  if (recognizer.result.ok !== host.result.ok || capture.result.ok !== host.result.ok || recognizer.result.unconsumedFrom !== host.result.unconsumedFrom || capture.result.unconsumedFrom !== host.result.unconsumedFrom) {
-    throw new Error("run({ profile: true }) changed recognition; the grammar is not profile-safe");
-  }
-  return {
-    ...host.result,
-    profile: {
-      recognizer: recognizer.profile,
-      structuralCapture: capture.profile,
-      hostConstruction: host.profile
-    }
-  };
-}
-
 // src/coverage.ts
 function dispatchMatcher(entry) {
   switch (entry.kind) {
@@ -12433,7 +13853,7 @@ function dispatchMatcher(entry) {
 var GRAMMAR_COVERAGE_DEFINITIONS = /* @__PURE__ */ Symbol.for("parseman.grammarCoverageDefinitions");
 function compiledGrammarCoverageDefinitions(grammar) {
   const definitions = grammar[GRAMMAR_COVERAGE_DEFINITIONS];
-  if (!Array.isArray(definitions) || !definitions.every((definition) => typeof definition === "object" && definition !== null && typeof definition.id === "string" && (definition.kind === "rule" || definition.kind === "choice-arm" || definition.kind === "dispatch-arm" || definition.kind === "label"))) {
+  if (!Array.isArray(definitions) || definitions.length === 0 || !definitions.every((definition) => typeof definition === "object" && definition !== null && typeof definition.id === "string" && (definition.kind === "rule" || definition.kind === "choice-arm" || definition.kind === "dispatch-arm" || definition.kind === "label"))) {
     throw new TypeError("grammar has no coverage definitions; enable grammarCoverage for this macro build");
   }
   return definitions;
@@ -12487,7 +13907,13 @@ function createGrammarCoverageCollector(definitions) {
     snapshot() {
       const hitList = [...hits].sort();
       const unhit = ordered.map((definition) => definition.id).filter((id) => !hits.has(id));
-      return { definitions: ordered, hits: hitList, unhit, ratio: ordered.length === 0 ? 1 : hitList.length / ordered.length };
+      return {
+        definitions: ordered,
+        hits: hitList,
+        unhit,
+        ratio: hitList.length / ordered.length,
+        measurable: ordered.length > 0
+      };
     },
     reset() {
       hits.clear();
@@ -12807,13 +14233,13 @@ function buildTriviaIndex(root, input = "", opts) {
 }
 
 // src/cst/walk.ts
-function isCombinator(value) {
+function isCombinator2(value) {
   return !!value && typeof value === "object" && "_def" in value && "_meta" in value && typeof value.parse === "function";
 }
 function reflectionFor(grammar) {
   const stamped = grammarReflectionOf(grammar);
   if (stamped) return stamped;
-  const entries = Object.entries(grammar).filter((entry) => isCombinator(entry[1]));
+  const entries = Object.entries(grammar).filter((entry) => isCombinator2(entry[1]));
   return collectGrammarReflection(entries);
 }
 function createVisitor(grammar, spec) {
@@ -12851,196 +14277,6 @@ function createVisitor(grammar, spec) {
   };
 }
 
-// src/cst/offset-model.ts
-var { isFinite } = Number;
-function floorIndex(arr, len, x) {
-  let lo = 0;
-  let hi = len - 1;
-  let ans = -1;
-  while (lo <= hi) {
-    const mid = lo + hi >>> 1;
-    if (arr[mid] <= x) {
-      ans = mid;
-      lo = mid + 1;
-    } else {
-      hi = mid - 1;
-    }
-  }
-  return ans;
-}
-var OffsetIndex = class {
-  /** Slot starts, sorted ascending. Parallel to `_ends`. */
-  _starts;
-  _ends;
-  count;
-  docStart;
-  docEnd;
-  constructor(slots, docStart = 0, docEnd) {
-    const sorted = [...slots].sort((a, b) => a.start - b.start);
-    const starts = [];
-    const ends = [];
-    let prevEnd = docStart;
-    for (const s of sorted) {
-      if (!isFinite(s.start) || !isFinite(s.end) || s.end < s.start) {
-        throw new RangeError(`OffsetIndex: invalid slot [${s.start}, ${s.end}]`);
-      }
-      if (s.start < prevEnd) {
-        throw new RangeError(`OffsetIndex: overlapping/out-of-order slot [${s.start}, ${s.end}] after end ${prevEnd}`);
-      }
-      starts.push(s.start);
-      ends.push(s.end);
-      prevEnd = s.end;
-    }
-    this._starts = starts;
-    this._ends = ends;
-    this.count = starts.length;
-    this.docStart = docStart;
-    this.docEnd = docEnd ?? (this.count ? Math.max(prevEnd, ends[ends.length - 1]) : docStart);
-  }
-  /** The slot at index `i` (0-based, source order), or undefined. */
-  slot(i) {
-    if (i < 0 || i >= this.count) return void 0;
-    return { start: this._starts[i], end: this._ends[i] };
-  }
-  /**
-   * Index of the gap that CONTAINS `offset`, in `[0, count]`. Gap `i` spans
-   * `[endOf(i-1), startOf(i))` where `endOf(-1)=docStart` and `startOf(count)=docEnd`.
-   * An offset that lands inside a slot returns that slot's TRAILING gap index
-   * (i.e. the gap after it) — callers querying at slot boundaries get the
-   * intuitive answer via `gapBefore`/`gapAfter`.
-   */
-  gapIndexAt(offset) {
-    const i = floorIndex(this._starts, this.count, offset);
-    if (i < 0) return 0;
-    if (offset < this._ends[i]) return i + 1;
-    return i + 1;
-  }
-  /** The gap at index `i` in `[0, count]`. */
-  gap(i) {
-    if (i < 0 || i > this.count) return void 0;
-    const start = i === 0 ? this.docStart : this._ends[i - 1];
-    const end = i === this.count ? this.docEnd : this._starts[i];
-    return { start, end };
-  }
-  /**
-   * The trivia gap immediately BEFORE `offset` (`[prevSlotEnd, offset)`), where
-   * `prevSlotEnd` is the end of the last slot ending at or before `offset` (or
-   * `docStart`). For a real slot start this is the gap preceding that slot; for an
-   * adjacent slot the gap is empty and agrees with `gapAfter` on the same seam.
-   */
-  gapBefore(offset) {
-    const e = floorIndex(this._ends, this.count, offset);
-    const start = e >= 0 ? this._ends[e] : this.docStart;
-    return { start, end: offset };
-  }
-  /**
-   * The trivia gap immediately AFTER `offset` (`[offset, nextSlotStart)`), where
-   * `nextSlotStart` is the least slot start at or after `offset` (or `docEnd`).
-   */
-  gapAfter(offset) {
-    return { start: offset, end: this._ceilStart(offset) };
-  }
-  /** Least slot start `>= offset`, else `docEnd`. */
-  _ceilStart(offset) {
-    let lo = 0;
-    let hi = this.count - 1;
-    let ans = this.docEnd;
-    while (lo <= hi) {
-      const mid = lo + hi >>> 1;
-      if (this._starts[mid] >= offset) {
-        ans = this._starts[mid];
-        hi = mid - 1;
-      } else {
-        lo = mid + 1;
-      }
-    }
-    return ans;
-  }
-  /** Is this gap empty (adjacent slots, no trivia)? */
-  isEmpty(gap) {
-    return gap.end <= gap.start;
-  }
-};
-var NL = 10;
-var CR = 13;
-var SP = 32;
-var TAB = 9;
-function gapText(source, gap) {
-  return gap.end > gap.start ? source.slice(gap.start, gap.end) : "";
-}
-function lineBreaksIn(source, gap) {
-  let n = 0;
-  for (let i = gap.start; i < gap.end; i++) {
-    const c = source.charCodeAt(i);
-    if (c === NL) n++;
-    else if (c === CR && source.charCodeAt(i + 1) !== NL) n++;
-  }
-  return n;
-}
-function blankLinesIn(source, gap) {
-  return Math.max(0, lineBreaksIn(source, gap) - 1);
-}
-function lineStartWithin(source, gap) {
-  for (let i = gap.end - 1; i >= gap.start; i--) {
-    const c = source.charCodeAt(i);
-    if (c === NL || c === CR) return i + 1;
-  }
-  return gap.start;
-}
-function indentWidth(source, gap) {
-  const ls = lineStartWithin(source, gap);
-  if (ls === gap.start) return 0;
-  return gap.end - ls;
-}
-function indentMixed(source, gap) {
-  const ls = lineStartWithin(source, gap);
-  let sawSpace = false;
-  let sawTab = false;
-  for (let i = ls; i < gap.end; i++) {
-    const c = source.charCodeAt(i);
-    if (c === SP) sawSpace = true;
-    else if (c === TAB) sawTab = true;
-  }
-  return sawSpace && sawTab;
-}
-function commentsIn(source, gap, comment) {
-  const re = new RegExp(comment.source, comment.flags.replace(/[gy]/g, "") + "g");
-  re.lastIndex = gap.start;
-  const out = [];
-  let m;
-  while ((m = re.exec(source)) && m.index < gap.end) {
-    if (m[0].length === 0) {
-      re.lastIndex++;
-      continue;
-    }
-    if (m.index + m[0].length > gap.end) break;
-    out.push({ start: m.index, end: m.index + m[0].length });
-  }
-  return out;
-}
-function gapIsSignificant(source, gap, comment) {
-  if (gap.end <= gap.start) return false;
-  if (lineBreaksIn(source, gap) > 0) return true;
-  if (comment && commentsIn(source, gap, comment).length > 0) return true;
-  return false;
-}
-function collectLeafSlots(root) {
-  const slots = [];
-  const visit = (n) => {
-    const kids = n.children;
-    if (kids && kids.length) {
-      for (const c of kids) visit(c);
-    } else if (n.span) {
-      slots.push({ start: n.span.start, end: n.span.end });
-    }
-  };
-  if (root) visit(root);
-  return slots;
-}
-function buildOffsetIndex(root, input = "") {
-  return new OffsetIndex(collectLeafSlots(root), 0, input.length);
-}
-
 // src/index.ts
 registerRegexAnalyzer(firstSetFromRegex);
 //# sourceMappingURL=index.cjs.map