parseman 0.44.0 → 0.45.0

package/dist/index.js

@@ -51,8 +51,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("");
@@ -1814,8 +1815,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] : [];
@@ -2005,7 +2009,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) {
@@ -2263,17 +2267,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)) {
@@ -2817,12 +2825,12 @@ function markUnusedValues(root) {
     }
   };
   const resolveRoot = (c) => {
-    const guard2 = /* @__PURE__ */ new Set();
+    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 {
@@ -2991,10 +2999,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":
@@ -3220,54 +3229,271 @@ 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 inside an imported factory, whose offsets the entry-file resolver cannot 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;
 }
@@ -3275,8 +3501,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;
 }
@@ -3457,6 +3682,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) {
@@ -3492,13 +3724,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);
@@ -3544,7 +3777,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);
@@ -3739,7 +3972,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.44.0";
+var PARSEMAN_VERSION = "0.45.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -4614,7 +4847,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;
@@ -5573,7 +5806,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;
@@ -7074,27 +7315,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 }`;
 }
@@ -7277,10 +7544,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;
 }
@@ -8029,9 +8320,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)
@@ -8041,7 +8334,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;
@@ -9113,9 +9406,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)),
@@ -9126,9 +9428,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`)
     ],
@@ -9136,6 +9448,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, "\\$&");
 }
@@ -9317,22 +9653,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";
@@ -9341,7 +9671,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);
@@ -9352,7 +9682,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` : ""}`
@@ -9369,21 +9698,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");
@@ -9407,19 +9728,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) {
@@ -9448,7 +9772,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}`;
@@ -9463,6 +9792,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;
@@ -9477,6 +9809,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);
@@ -9571,6 +9905,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;
@@ -9578,6 +9915,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));
   }
@@ -9771,7 +10110,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":
@@ -9806,6 +10145,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;
@@ -9813,6 +10155,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);
@@ -9971,12 +10315,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 [];
   }
@@ -9997,6 +10345,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]);
 }
@@ -10102,102 +10461,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;
@@ -10240,7 +10503,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;
@@ -10248,9 +10521,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: [],
@@ -10296,11 +10572,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,
@@ -10315,6 +10593,7 @@ function compile(combinator, mapFnSources, opts) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...rawEntryDecls,
     ...lineTrackDecls,
     ...lineSpanDecls,
     ...ctx.regexDecls,
@@ -10364,8 +10643,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 {
@@ -10431,7 +10709,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);
@@ -10450,9 +10727,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: [],
@@ -10548,6 +10828,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;
@@ -10563,6 +10846,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)})`,
@@ -10647,6 +10932,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)),
@@ -10656,26 +10942,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) => {
@@ -10721,14 +10987,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}`),
@@ -10798,11 +11066,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":
@@ -10884,7 +11153,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(", ")}`);
     }
@@ -10893,6 +11162,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) => {
@@ -11205,7 +11475,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":
@@ -11238,6 +11508,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(", ")} }` : "";
@@ -11246,8 +11519,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)})`;
       }
@@ -11328,12 +11607,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).
@@ -11449,17 +11730,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 = [];
@@ -11576,12 +11846,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 });
@@ -11608,9 +11872,175 @@ 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/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 formatGrammarDiagnosis(d) {
+  const s = d.summary;
+  const lines = [];
+  lines.push(
+    d.ok ? `parseman: grammar OK \u2014 ${s.gated}/${s.totalChoices} choice(s) gate on first char${s.recoverable > 0 ? `, ${s.recoverable} recoverable` : ""}${s.accepted > 0 ? `, ${s.accepted} accepted` : ""}${s.deferred > 0 ? `, ${s.deferred} deferred to the fusing artifact` : ""}.` : `parseman: grammar NOT OK \u2014 ${blockingOf(d).length} blocking finding(s) over ${s.totalChoices} examined choice(s).`
+  );
+  if (s.unanalysable > 0) {
+    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/combinators/gate.ts
 function gate(predicate) {
   const meta = {
@@ -11630,9 +12060,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 };
@@ -11859,9 +12286,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 } });
@@ -12154,6 +12581,35 @@ function parseDoc(registry, rootRule, input, opts = {}) {
 }
 
 // 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;
@@ -12256,37 +12712,11 @@ function runOnce(entry, input, options, phase, profileState) {
     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
-    }
-  };
+  if (!options.profile) return guardRemovedFields(runOnce(entry, input, options));
+  throw new TypeError(
+    "run({ profile: true }) is unavailable: profiling counters are no longer compiled into parser artifacts, and the interpreter does not implement them yet. Profiling is moving to interpreted mode."
+  );
 }
 
 // src/coverage.ts
@@ -12303,7 +12733,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;
@@ -12357,7 +12787,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();
@@ -12677,13 +13113,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) {
@@ -12721,201 +13157,10 @@ 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);
 export {
   GRAMMAR_COVERAGE_DEFINITIONS,
-  OffsetIndex,
   absoluteSpanAt,
   absoluteSpanCST,
   absolutize,
@@ -12931,16 +13176,12 @@ export {
   applyEdit,
   attempt,
   balanced,
-  blankLinesIn,
   buildLineIndex,
-  buildOffsetIndex,
   buildRootTriviaIndex,
   buildTriviaIndex,
   charClassMembers,
   choice,
   classifiedTrivia,
-  collectLeafSlots,
-  commentsIn,
   compile,
   compiledGrammarCoverageDefinitions,
   completionsAt,
@@ -12953,6 +13194,7 @@ export {
   createLineIndex,
   createVisitor,
   cstBuildHost,
+  diagnoseGrammar,
   dispatch,
   duplicationFindingCount,
   endsWith,
@@ -12962,21 +13204,15 @@ export {
   firstSetToString,
   formatDuplicationFindings,
   formatGatingWarnings,
-  gapIsSignificant,
-  gapText,
+  formatGrammarDiagnosis,
   gate,
   grammarCoverageDefinitions,
-  guard,
-  indentMixed,
-  indentWidth,
   isParseError,
   keywordAlternationHazards,
   keywordRegexShape,
   keywords,
   label,
   leaf,
-  lineBreaksIn,
-  lineStartWithin,
   literal,
   makeWhen,
   makeWord,