parseman 0.44.0 → 0.45.0

package/dist/plugin/index.js

@@ -1,16 +1,16 @@
 // src/plugin/index.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
 import { createUnplugin } from "unplugin";
-import { parseSync as parseSync2 } from "oxc-parser";
+import { parseSync as parseSync3 } from "oxc-parser";
 import { ResolverFactory } from "oxc-resolver";
 import MagicString from "magic-string";
 
 // src/combinators/first-set.ts
-function resolveNamedRef(p, resolve2) {
-  if (resolve2 === void 0) return void 0;
+function resolveNamedRef(p, resolve3) {
+  if (resolve3 === void 0) return void 0;
   const name = p._ruleName;
-  return name === void 0 ? void 0 : resolve2(name);
+  return name === void 0 ? void 0 : resolve3(name);
 }
 function union(a, b) {
   if (a.kind === "any" || b.kind === "any") return { kind: "any" };
@@ -32,12 +32,12 @@ function fromChar(code) {
   return { kind: "ranges", ranges: [{ lo: code, hi: code }] };
 }
 function startsFirstSet(combinator, input, pos) {
-  const fs2 = combinator._meta.firstSet;
-  if (fs2.kind === "any") return true;
-  if (fs2.kind === "empty") return false;
+  const fs3 = combinator._meta.firstSet;
+  if (fs3.kind === "any") return true;
+  if (fs3.kind === "empty") return false;
   const code = input.codePointAt(pos);
   if (code === void 0) return false;
-  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
+  for (const r of fs3.ranges) if (code >= r.lo && code <= r.hi) return true;
   return false;
 }
 function fromRange(lo, hi) {
@@ -49,18 +49,19 @@ function any() {
 function empty() {
   return { kind: "empty" };
 }
-function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
+function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve3) {
   if (seen.has(p)) return true;
   seen.add(p);
-  const me = (c) => matchesEmpty(c, seen, resolve2);
+  const me = (c) => matchesEmpty(c, seen, resolve3);
   const d = p._def;
   switch (d.tag) {
     case "literal":
       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("");
@@ -106,7 +107,7 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       try {
         return me(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve2);
+        const t = resolveNamedRef(p, resolve3);
         return t ? me(t) : true;
       }
     default:
@@ -132,29 +133,29 @@ function narrowBy(acc, constraint) {
   }
   return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
 }
-function applyAssertion(fs2, assertion) {
-  if (assertion === null) return fs2;
-  if (fs2.kind === "empty") return assertion;
-  return narrowBy(fs2, assertion) ?? fs2;
+function applyAssertion(fs3, assertion) {
+  if (assertion === null) return fs3;
+  if (fs3.kind === "empty") return assertion;
+  return narrowBy(fs3, assertion) ?? fs3;
 }
 function sequenceFirstSet(parsers) {
-  let fs2 = empty();
+  let fs3 = empty();
   let assertion = null;
   for (const p of parsers) {
     if (isPositiveLookahead(p)) {
       assertion = narrowBy(assertion, p._meta.firstSet);
       continue;
     }
-    if (!isZeroWidthAssertion(p)) fs2 = union(fs2, p._meta.firstSet);
-    if (!matchesEmpty(p)) return applyAssertion(fs2, assertion);
+    if (!isZeroWidthAssertion(p)) fs3 = union(fs3, p._meta.firstSet);
+    if (!matchesEmpty(p)) return applyAssertion(fs3, assertion);
   }
-  return applyAssertion(fs2, assertion);
+  return applyAssertion(fs3, assertion);
 }
-function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
+function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve3) {
   if (seen.has(p)) return any();
   seen.add(p);
-  const fs2 = (c) => firstSetOf(c, seen, resolve2);
-  const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve2);
+  const fs3 = (c) => firstSetOf(c, seen, resolve3);
+  const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve3);
   const d = p._def;
   switch (d.tag) {
     case "literal":
@@ -163,17 +164,17 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       return p._meta.firstSet;
     // terminals: no refs, cached set is exact
     case "dispatch":
-      return fs2(d.selector);
+      return fs3(d.selector);
     case "lazy":
       try {
-        return fs2(d.thunk());
+        return fs3(d.thunk());
       } catch {
-        const t = resolveNamedRef(p, resolve2);
-        return t ? fs2(t) : any();
+        const t = resolveNamedRef(p, resolve3);
+        return t ? fs3(t) : any();
       }
     case "choice": {
       let out = empty();
-      for (const arm of d.parsers) out = union(out, fs2(arm));
+      for (const arm of d.parsers) out = union(out, fs3(arm));
       return out;
     }
     case "sequence": {
@@ -181,17 +182,17 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       let assertion = null;
       for (const term of d.parsers) {
         if (isPositiveLookahead(term)) {
-          assertion = narrowBy(assertion, fs2(term));
+          assertion = narrowBy(assertion, fs3(term));
           continue;
         }
-        if (!isZeroWidthAssertion(term)) out = union(out, fs2(term));
+        if (!isZeroWidthAssertion(term)) out = union(out, fs3(term));
         if (!empties(term)) return applyAssertion(out, assertion);
       }
       return applyAssertion(out, assertion);
     }
     case "peek": {
       const inner = d.parser;
-      return empties(inner) ? any() : fs2(inner);
+      return empties(inner) ? any() : fs3(inner);
     }
     case "oneOrMore":
     case "many":
@@ -204,12 +205,12 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
     case "node":
     case "grammar":
     case "expect":
-      return fs2(d.parser);
+      return fs3(d.parser);
     case "sepBy":
-      return fs2(d.parser);
+      return fs3(d.parser);
     // both min 0 and min 1 start with the item
     case "skip":
-      return fs2(d.main);
+      return fs3(d.main);
     default:
       return p._meta.firstSet;
   }
@@ -680,13 +681,13 @@ function shortScanner(source, flags) {
     return minOne && end === pos ? null : end;
   };
 }
-function asciiCaseFold(fs2) {
-  if (fs2.kind !== "ranges") return fs2;
-  const ranges = fs2.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
+function asciiCaseFold(fs3) {
+  if (fs3.kind !== "ranges") return fs3;
+  const ranges = fs3.ranges.map((r) => ({ lo: r.lo, hi: r.hi }));
   const add = (lo, hi) => {
     if (lo <= hi) ranges.push({ lo, hi });
   };
-  for (const r of fs2.ranges) {
+  for (const r of fs3.ranges) {
     const uLo = Math.max(r.lo, 65), uHi = Math.min(r.hi, 90);
     add(uLo + 32, uHi + 32);
     const lLo = Math.max(r.lo, 97), lHi = Math.min(r.hi, 122);
@@ -744,9 +745,9 @@ function charNode(set, nl) {
   return { t: "char", set, nl };
 }
 function rangesToSet(ranges) {
-  let fs2 = empty();
-  for (const [lo, hi] of ranges) fs2 = union(fs2, fromRange(lo, hi));
-  return fs2;
+  let fs3 = empty();
+  for (const [lo, hi] of ranges) fs3 = union(fs3, fromRange(lo, hi));
+  return fs3;
 }
 function rangesHaveNewline(ranges) {
   return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
@@ -952,17 +953,17 @@ function firstSet(n) {
     case "rep":
       return firstSet(n.node);
     case "alt": {
-      let fs2 = empty();
-      for (const arm of n.arms) fs2 = union(fs2, firstSet(arm));
-      return fs2;
+      let fs3 = empty();
+      for (const arm of n.arms) fs3 = union(fs3, firstSet(arm));
+      return fs3;
     }
     case "seq": {
-      let fs2 = empty();
+      let fs3 = empty();
       for (const part of n.parts) {
-        fs2 = union(fs2, firstSet(part));
+        fs3 = union(fs3, firstSet(part));
         if (!nullable(part)) break;
       }
-      return fs2;
+      return fs3;
     }
   }
 }
@@ -1637,12 +1638,12 @@ function orSentinel(a, b) {
     }
   };
 }
-function firstSetSentinel(fs2) {
-  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
-  const ranges = fs2.ranges;
+function firstSetSentinel(fs3) {
+  if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return null;
+  const ranges = fs3.ranges;
   return {
     _tag: "firstSetSentinel",
-    _meta: { firstSet: fs2, canMatchNewline: false, isTrivia: false },
+    _meta: { firstSet: fs3, canMatchNewline: false, isTrivia: false },
     _def: { tag: "unknown" },
     parse(input, pos) {
       const code = pos < input.length ? input.codePointAt(pos) : void 0;
@@ -1684,11 +1685,11 @@ function sequence(...parsers) {
   let followSentinels;
   function parseTolerant(input, pos, ctx) {
     followSentinels ??= parsers.map((_, i) => {
-      const fs2 = parsers.slice(i + 1).reduce(
+      const fs3 = parsers.slice(i + 1).reduce(
         (acc, p) => union(acc, firstSetOf(p)),
         { kind: "empty" }
       );
-      return firstSetSentinel(fs2);
+      return firstSetSentinel(fs3);
     });
     const values = def.valueUnused ? void 0 : [];
     let cur = pos;
@@ -1831,8 +1832,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] : [];
@@ -2019,7 +2023,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) {
@@ -2135,10 +2139,10 @@ function codesToFirstSet(codes) {
   ranges.push({ lo, hi });
   return { kind: "ranges", ranges };
 }
-function inFirstSet(code, fs2) {
-  if (fs2.kind === "any") return true;
-  if (fs2.kind === "empty") return false;
-  for (const r of fs2.ranges) if (code >= r.lo && code <= r.hi) return true;
+function inFirstSet(code, fs3) {
+  if (fs3.kind === "any") return true;
+  if (fs3.kind === "empty") return false;
+  for (const r of fs3.ranges) if (code >= r.lo && code <= r.hi) return true;
   return false;
 }
 function areDisjoint(sets) {
@@ -2151,9 +2155,9 @@ function areDisjoint(sets) {
 function buildAsciiDispatch(parsers) {
   const table = Array(128).fill(-1);
   for (let i = 0; i < parsers.length; i++) {
-    const fs2 = parsers[i]._meta.firstSet;
-    if (fs2.kind !== "ranges") continue;
-    for (const { lo, hi } of fs2.ranges) {
+    const fs3 = parsers[i]._meta.firstSet;
+    if (fs3.kind !== "ranges") continue;
+    for (const { lo, hi } of fs3.ranges) {
       for (let code = Math.max(0, lo); code <= Math.min(127, hi); code++) {
         table[code] = i;
       }
@@ -2274,17 +2278,21 @@ function when(key, parser2, 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)) {
@@ -2791,12 +2799,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 {
@@ -2938,10 +2946,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":
@@ -3164,54 +3173,275 @@ 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 endDegradationCapture() {
+  const sink = _sinks.pop();
+  return sink ? [...sink.values()] : [];
+}
+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;
 }
@@ -3219,8 +3449,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;
 }
@@ -3401,6 +3630,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) {
@@ -3436,13 +3672,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);
@@ -3488,7 +3725,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);
@@ -3683,7 +3920,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");
@@ -3703,346 +3940,11 @@ function assertHostModeCompatible(mode, build, hostBranchElided = true) {
 }
 
 // src/analysis/gating.ts
-var isAny = (fs2) => fs2.kind === "any";
-function intersects2(a, b) {
-  if (a.kind === "any" || b.kind === "any") return true;
-  if (a.kind === "empty" || b.kind === "empty") return false;
-  for (const ra of a.ranges) for (const rb of b.ranges) if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
-  return false;
-}
-function intersection(a, b) {
-  if (a.kind === "any") return b;
-  if (b.kind === "any") return a;
-  if (a.kind === "empty" || b.kind === "empty") return { kind: "empty" };
-  const ranges = [];
-  for (const ra of a.ranges) for (const rb of b.ranges) {
-    const lo = Math.max(ra.lo, rb.lo);
-    const hi = Math.min(ra.hi, rb.hi);
-    if (lo <= hi) ranges.push({ lo, hi });
-  }
-  return ranges.length === 0 ? { kind: "empty" } : { kind: "ranges", ranges };
-}
-function combine(sets) {
-  let acc = { kind: "empty" };
-  for (const s of sets) {
-    if (s.kind === "any") return { kind: "any" };
-    if (s.kind === "empty") continue;
-    acc = acc.kind === "ranges" ? { kind: "ranges", ranges: [...acc.ranges, ...s.ranges] } : s;
-  }
-  return acc;
-}
 var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
-function firstSetToString(fs2) {
-  if (fs2.kind === "any") return "ANY";
-  if (fs2.kind === "empty") return "(empty)";
-  return fs2.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
-}
-var ruleNameOf2 = (p) => p._ruleName;
-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."
-};
-function classifyBroadArm(arm, resolve2) {
-  const seen = /* @__PURE__ */ new Set();
-  const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
-  const walk = (p) => {
-    if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
-    seen.add(p);
-    const d = p._def;
-    switch (d.tag) {
-      case "literal":
-      case "regex":
-      case "keywords":
-        return isAny(p._meta.firstSet) ? { cause: "broad-recognizer", detail: `broad recognizer (${d.tag})` } : null;
-      case "not":
-        return { cause: "leading-not", detail: "leading not(...) (first-set ANY)" };
-      // peek() CARRIES its body's first-set, so it is only broad when the body is
-      // (or the body is nullable) — walk in for the real cause.
-      case "peek":
-        return walk(d.parser);
-      case "scanTo":
-        return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
-      // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
-      // its own — it is the poison. `withCtx`/`recover` FORWARD their inner
-      // first-set (see firstSetOf), so a broad result comes from the inner parser:
-      // walk into it for a precise cause.
-      case "guard":
-        return { cause: "opaque-wrapper", detail: `opaque wrapper (${d.tag})` };
-      // attempt/withCtx/recover FORWARD their inner first-set (transparent for
-      // dispatch), so a broad result comes from the inner parser — walk into it.
-      case "attempt":
-      case "withCtx":
-      case "recover":
-        return walk(d.parser);
-      case "lazy": {
-        const name = p._ruleName;
-        let target;
-        try {
-          target = d.thunk();
-        } catch {
-          const bound = name !== void 0 ? resolve2?.(name) : void 0;
-          if (bound === void 0)
-            return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
-          target = bound;
-        }
-        const inner = walk(target);
-        if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
-        return inner;
-      }
-      case "optional":
-      case "many": {
-        const inner = walk(d.parser);
-        return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
-      }
-      case "oneOrMore":
-      case "transform":
-      case "label":
-      case "field":
-      case "trivia":
-      case "token":
-      case "leaf":
-      case "node":
-      case "grammar":
-      case "expect":
-        return walk(d.parser);
-      case "skip":
-        return walk(d.main);
-      case "sequence": {
-        let sawNullablePrefix = false;
-        for (const t of d.parsers) {
-          if (t._def.tag === "not") {
-            sawNullablePrefix = true;
-            continue;
-          }
-          if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve2))) {
-            const inner = walk(t);
-            if (sawNullablePrefix)
-              return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
-            return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
-          }
-          if (matchesEmpty(t, /* @__PURE__ */ new Set(), resolve2)) {
-            sawNullablePrefix = true;
-            continue;
-          }
-          return null;
-        }
-        return { cause: "broad-recognizer", detail: "sequence of only nullable/zero-width terms" };
-      }
-      case "choice": {
-        for (const a of d.parsers) {
-          const r = walk(a);
-          if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
-        }
-        return null;
-      }
-      case "dispatch":
-        return walk(d.selector);
-      default:
-        return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
-    }
-  };
-  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
-}
-function peelToLeading(arm) {
-  let d = arm._def;
-  let cur = arm;
-  for (; ; ) {
-    if (d.tag === "node" || d.tag === "grammar" || d.tag === "transform" || d.tag === "label" || d.tag === "attempt") {
-      cur = d.parser;
-      d = cur._def;
-      continue;
-    }
-    break;
-  }
-  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) => {
-    const lead = peelToLeading(arm);
-    const ld = lead._def;
-    if (ld.tag === "not") {
-      const inner = ld.parser;
-      if (inner._def.tag === "not") {
-        out.push({
-          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."
-        });
-      } 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."
-        });
-      }
-    }
-    if (ld.tag === "regex" && KEYWORD_REGEX_RE.test(ld.source)) {
-      out.push({
-        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).`
-      });
-    }
-  });
-  return out;
-}
-function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
-}
-function analyzeGatingRules(ruleMap, opts) {
-  const raw = [];
-  const antiPatterns = [];
-  const unanalysable = [];
-  const seenUnanalysable = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const noteUnanalysable = (u) => {
-    const key = `${u.rule}\0${u.kind}`;
-    if (seenUnanalysable.has(key)) return;
-    seenUnanalysable.add(key);
-    unanalysable.push(u);
-  };
-  const visit = (p, enclosingRule) => {
-    if (visited.has(p)) return;
-    visited.add(p);
-    const def = p?._def;
-    if (def === null || typeof def !== "object") {
-      noteUnanalysable(
-        typeof p === "function" ? {
-          rule: enclosingRule,
-          kind: "fused-rule",
-          reason: "fused rule function \u2014 a compose()/fuse result has no combinator graph. Analyze the composed grammar itself (analyzeGrammarGating) so the carried IR is re-lowered first."
-        } : {
-          rule: enclosingRule,
-          kind: "not-a-combinator",
-          reason: `value of type ${p === null ? "null" : typeof p} is not a combinator and carries no _def descriptor.`
-        }
-      );
-      return;
-    }
-    const d = def;
-    const rule = ruleNameOf2(p) ?? enclosingRule;
-    if (d.tag === "choice") {
-      raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
-      antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
-    }
-    const rec = d;
-    const kids = [];
-    if (Array.isArray(rec.parsers)) kids.push(...rec.parsers);
-    for (const k of ["parser", "main", "skipped", "separator", "sentinel"])
-      if (rec[k]) kids.push(rec[k]);
-    if (d.tag === "dispatch") {
-      kids.push(d.selector);
-      for (const c of d.cases) kids.push(c.parser);
-      if (d.matchers) for (const c of d.matchers) kids.push(c.parser);
-      if (d.otherwise !== void 0) kids.push(d.otherwise);
-    }
-    if (Array.isArray(rec.skip)) kids.push(...rec.skip);
-    if (d.tag === "lazy") {
-      try {
-        kids.push(d.thunk());
-      } catch {
-      }
-    }
-    for (const k of kids) visit(k, rule);
-  };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
-  const perRule = /* @__PURE__ */ new Map();
-  for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
-  const seenInRule = /* @__PURE__ */ new Map();
-  const accept = new Set(opts?.accept ?? []);
-  const usedAccept = /* @__PURE__ */ new Set();
-  const choices = raw.map(({ g, rule }) => {
-    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 gated = choices.filter((c) => c.gates === "yes").length;
-  const recoverable = choices.filter((c) => c.gates === "recoverable").length;
-  const ungated = choices.filter((c) => c.gates === "no" && !c.accepted && !c.deferred);
-  const accepted = choices.filter((c) => c.gates === "no" && c.accepted);
-  const deferred = choices.filter((c) => c.gates === "no" && !c.accepted && c.deferred);
-  const acceptedUnused = [...accept].filter((id) => !usedAccept.has(id));
-  return {
-    totalChoices: choices.length,
-    gated,
-    recoverable,
-    unanalysable,
-    ungated,
-    accepted,
-    deferred,
-    acceptedUnused,
-    choices,
-    antiPatterns
-  };
-}
-function analyzeChoice(p, d, rule, resolve2) {
-  const arms = d.parsers;
-  const shallow = arms.map((a) => a._meta.firstSet);
-  const deep = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve2));
-  const anyArms = deep.map((fs2, index) => ({ fs: fs2, index })).filter((x) => isAny(x.fs)).map(({ index }) => {
-    const { cause, detail, unresolvedExternal } = classifyBroadArm(arms[index], resolve2);
-    return { index, cause, detail, shallowAnyOnly: false, unresolvedExternal: unresolvedExternal === true, suggestion: SUGGESTIONS[cause] };
-  });
-  const overlaps = [];
-  for (let i = 0; i < deep.length; i++)
-    for (let j = i + 1; j < deep.length; j++)
-      if (!isAny(deep[i]) && !isAny(deep[j]) && intersects2(deep[i], deep[j]))
-        overlaps.push({
-          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."
-        });
-  let gates;
-  if (d.disjoint) gates = "yes";
-  else if (anyArms.length === 0 && overlaps.length === 0) gates = "recoverable";
-  else gates = "no";
-  const deferred = gates === "no" && overlaps.length === 0 && anyArms.length > 0 && anyArms.every((a) => a.unresolvedExternal);
-  return {
-    rule,
-    strategy: d.strategy?.tag ?? "firstMatch",
-    gates,
-    deferred,
-    combinedFirstSet: { shallow: combine(shallow), deep: combine(deep) },
-    anyArms,
-    overlaps
-  };
-}
-function formatGatingWarnings(report) {
-  const lines = [];
-  if (report.unanalysable.length > 0) {
-    lines.push(
-      `parseman gating: ${report.unanalysable.length} rule(s) UNANALYSABLE \u2014 this report is PARTIAL (${report.totalChoices} choice(s) examined). An empty finding list below does NOT mean the grammar is clean.`
-    );
-    for (const u of report.unanalysable)
-      lines.push(`  \xB7 ${u.rule} [${u.kind}]: ${u.reason}`);
-  }
-  for (const c of report.ungated) {
-    lines.push(`parseman gating: choice @ ${c.id} is UNGATED [${c.strategy}] \u2014 no first-char dispatch; every position speculatively enters doomed arms.`);
-    for (const a of c.anyArms)
-      lines.push(`  \xB7 arm[${a.index}] first-set ANY (${a.cause}): ${a.detail}
-    fix: ${a.suggestion}`);
-    for (const o of c.overlaps)
-      lines.push(`  \xB7 arm[${o.a}] \u2229 arm[${o.b}] overlap on ${firstSetToString(o.on)}
-    fix: ${o.suggestion}`);
-    lines.push(`    (intentional? accept it in the gating snapshot: { accept: ['${c.id}'] }.)`);
-  }
-  for (const ap of report.antiPatterns)
-    lines.push(`parseman anti-pattern [${ap.kind}] @ ${ap.rule} arm[${ap.armIndex}]: ${ap.message}`);
-  return lines;
+function firstSetToString(fs3) {
+  if (fs3.kind === "any") return "ANY";
+  if (fs3.kind === "empty") return "(empty)";
+  return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
 
 // src/analysis/duplication.ts
@@ -4085,7 +3987,7 @@ function childrenOf2(d) {
     }
   }
 }
-var ruleNameOf3 = (p) => p._ruleName;
+var ruleNameOf2 = (p) => p._ruleName;
 var fnKey = (src, fn) => src ?? (typeof fn === "function" ? String(fn) : "");
 function payloadKey(p, d) {
   switch (d.tag) {
@@ -4096,7 +3998,7 @@ function payloadKey(p, d) {
     case "keywords":
       return `keywords\0${[...d.words].join("
")}\0${d.caseInsensitive}\0${d.boundary ?? ""}`;
     case "lazy": {
-      const n = ruleNameOf3(p);
+      const n = ruleNameOf2(p);
       return n === void 0 ? `ref\0#${anonId(p)}` : `ref\0${n}`;
     }
     case "label":
@@ -4165,7 +4067,7 @@ var Interner = class {
 var MAX_RENDER = 160;
 function render(p, depth = 3) {
   const d = p._def;
-  const name = ruleNameOf3(p);
+  const name = ruleNameOf2(p);
   switch (d.tag) {
     case "literal":
       return `literal('${d.value}')`;
@@ -4353,7 +4255,7 @@ function keywordAlternationHazards(words, boundary) {
   return out;
 }
 function analyzeDuplication(entry, opts) {
-  return analyzeDuplicationRules([[ruleNameOf3(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeDuplicationRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function assertAnalyzable(ruleMap) {
   for (const [name, rule] of ruleMap) {
@@ -4391,11 +4293,11 @@ function analyzeDuplicationRules(ruleMap, opts) {
     return n;
   };
   const visited = /* @__PURE__ */ new Map();
-  const visit = (p, rule, path2, enclosingNode, enclosingReducer) => {
+  const visit = (p, rule, path3, enclosingNode, enclosingReducer) => {
     if (visited.has(p)) return;
     const d = p._def;
-    const own = ruleNameOf3(p);
-    const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path: path2 };
+    const own = ruleNameOf2(p);
+    const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path: path3 };
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
     const innerReducer = enclosingReducer || d.tag === "node" && (d.build !== void 0 || d.buildSrc !== void 0) || d.tag === "transform" || d.tag === "leaf";
@@ -4407,12 +4309,12 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (d.tag === "lazy") {
       try {
         const target = d.thunk();
-        visit(target, ruleNameOf3(target) ?? ruleNameOf3(p) ?? here.rule, "", null, false);
+        visit(target, ruleNameOf2(target) ?? ruleNameOf2(p) ?? here.rule, "", null, false);
       } catch {
       }
     }
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf3(root) ?? name, "", null, false);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name, "", null, false);
   const accept = new Set(opts?.accept ?? []);
   const used = /* @__PURE__ */ new Set();
   const keep = (f) => {
@@ -4429,10 +4331,10 @@ function analyzeDuplicationRules(ruleMap, opts) {
   const divergentNodes = findDivergentNodes(visited, shapeOf);
   const structureLoss = findStructureLoss(visited, opts?.resolveRef);
   const keywordRegexes = findKeywordRegexes(visited);
-  const subsume = (fs2) => {
+  const subsume = (fs3) => {
     const covered = /* @__PURE__ */ new Set();
     const surviving = /* @__PURE__ */ new Set();
-    for (const f of [...fs2].sort((a, b) => b.savings - a.savings)) {
+    for (const f of [...fs3].sort((a, b) => b.savings - a.savings)) {
       if (f._members.every((m) => covered.has(m))) continue;
       surviving.add(f.id);
       for (const m of f._members) markSubtree(m, covered);
@@ -4555,10 +4457,10 @@ function findNearDuplicates(visited, interner, shapeOf, minSize) {
   return out.sort((a, b) => b.savings - a.savings);
 }
 function findDivergentSlot(members, shapeOf) {
-  const path2 = [];
+  const path3 = [];
   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;
@@ -4570,14 +4472,14 @@ function findDivergentSlot(members, shapeOf) {
     }
     if (diff.length !== 1) break;
     const i = diff[0];
-    path2.push(i);
+    path3.push(i);
     defs.push(d0);
     cur = kidLists.map((k) => k[i]);
     const nextArity = childrenOf2(cur[0]._def).length;
     const samePayload = cur.every((c) => payloadKey(c, c._def) === payloadKey(cur[0], cur[0]._def));
     if (!samePayload || nextArity === 0) break;
   }
-  if (path2.length === 0) return null;
+  if (path3.length === 0) return null;
   let slotSize = 0;
   const sizeOf = (p) => {
     let n = 1;
@@ -4585,14 +4487,14 @@ function findDivergentSlot(members, shapeOf) {
     return n;
   };
   for (const c of cur) slotSize = Math.max(slotSize, sizeOf(c));
-  return { path: path2, defs, variants: cur, slotSize };
+  return { path: path3, defs, variants: cur, slotSize };
 }
-function renderWithHole(p, path2, depth = 0) {
-  if (depth === path2.length) return "\u2039slot\u203A";
+function renderWithHole(p, path3, depth = 0) {
+  if (depth === path3.length) return "\u2039slot\u203A";
   const d = p._def;
   const kids = childrenOf2(d);
-  const idx = path2[depth];
-  const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path2, depth + 1) : render(k, 2));
+  const idx = path3[depth];
+  const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path3, depth + 1) : render(k, 2));
   switch (d.tag) {
     case "sequence":
       return `sequence(${parts.join(", ")})`;
@@ -4796,13 +4698,13 @@ function findRegexClasses(visited) {
   }
   return out.sort((a, b) => Number(b.drifted) - Number(a.drifted) || b.count - a.count);
 }
-function intersects3(a, b) {
+function intersects2(a, b) {
   if (a.kind === "any" || b.kind === "any") return true;
   if (a.kind === "empty" || b.kind === "empty") return false;
   for (const ra of a.ranges) for (const rb of b.ranges) if (ra.lo <= rb.hi && rb.lo <= ra.hi) return true;
   return false;
 }
-function intersection2(a, b) {
+function intersection(a, b) {
   if (a.kind === "any") return b;
   if (b.kind === "any") return a;
   if (a.kind === "empty" || b.kind === "empty") return { kind: "empty" };
@@ -4831,19 +4733,19 @@ function leadingRegex(arm) {
   const t = termsOf(arm)[0];
   return t !== void 0 && t._def.tag === "regex";
 }
-function findOverlaps(visited, shapeOf, resolve2) {
+function findOverlaps(visited, shapeOf, resolve3) {
   const out = [];
   for (const v2 of visited.values()) {
     const d = v2.d;
     if (d.tag !== "choice") continue;
     const arms = d.parsers;
-    const fs2 = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve2));
+    const fs3 = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve3));
     const strategy = d.strategy;
     for (let i = 0; i < arms.length; i++) {
       for (let j = i + 1; j < arms.length; j++) {
-        const A = fs2[i], B = fs2[j];
+        const A = fs3[i], B = fs3[j];
         if (A.kind === "any" || B.kind === "any") continue;
-        if (!intersects3(A, B)) continue;
+        if (!intersects2(A, B)) continue;
         const ta = termsOf(arms[i]), tb = termsOf(arms[j]);
         let shared = 0;
         while (shared < ta.length && shared < tb.length && shapeOf(ta[shared]) === shapeOf(tb[shared])) shared++;
@@ -4855,7 +4757,7 @@ function findOverlaps(visited, shapeOf, resolve2) {
           site: v2.site,
           a: i,
           b: j,
-          on: intersection2(A, B),
+          on: intersection(A, B),
           sharedLeadingTerms: shared,
           sharedPrefix: shared > 0 ? clamp(ta.slice(0, shared).map((t) => render(t, 2)).join(", ")) : null,
           handledByStrategy: handled,
@@ -5157,7 +5059,7 @@ function nestedNodeTypes(root, out, seen, isRoot) {
   for (const k of childrenOf2(d)) nestedNodeTypes(k, out, seen, false);
 }
 var MAX_LOST_TYPES = 8;
-function findStructureLoss(visited, resolve2) {
+function findStructureLoss(visited, resolve3) {
   const nestedCache = /* @__PURE__ */ new Map();
   const nested = (p) => {
     const hit = nestedCache.get(p);
@@ -5174,18 +5076,18 @@ function findStructureLoss(visited, resolve2) {
     const arms = d.parsers;
     const resolved = arms.map(resolveArm);
     const nodeTypes = resolved.map(wrappingNodeType);
-    const fs2 = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve2));
+    const fs3 = arms.map((a) => firstSetOf(a, /* @__PURE__ */ new Set(), resolve3));
     for (let i = 0; i < arms.length; i++) {
       if (d.gates[i] != null) continue;
       const type = nodeTypes[i] ?? null;
       if (type === null) continue;
       if (nested(resolved[i]).size !== 0) continue;
-      const A = fs2[i];
+      const A = fs3[i];
       if (A.kind === "any") continue;
       for (let j = i + 1; j < arms.length; j++) {
         if (nodeTypes[j] !== type) continue;
-        const B = fs2[j];
-        if (B.kind === "any" || !intersects3(A, B)) continue;
+        const B = fs3[j];
+        if (B.kind === "any" || !intersects2(A, B)) continue;
         const lost = nested(resolved[j]);
         if (lost.size === 0) continue;
         const lostNodeTypes = [...lost].sort();
@@ -5196,7 +5098,7 @@ function findStructureLoss(visited, resolve2) {
           nodeType: type,
           earlier: i,
           later: j,
-          on: intersection2(A, B),
+          on: intersection(A, B),
           lostNodeTypes: lostNodeTypes.slice(0, MAX_LOST_TYPES),
           earlierShape: clamp(render(resolved[i], 3)),
           laterShape: clamp(render(resolved[j], 3)),
@@ -5454,11 +5356,11 @@ function buildBalancedInterior(open, close, skips) {
   return combi;
 }
 function firstSetClassChars(c) {
-  const fs2 = c._meta.firstSet;
-  if (fs2.kind === "empty") return [];
-  if (fs2.kind !== "ranges") return null;
+  const fs3 = c._meta.firstSet;
+  if (fs3.kind === "empty") return [];
+  if (fs3.kind !== "ranges") return null;
   const out = [];
-  for (const { lo, hi } of fs2.ranges) {
+  for (const { lo, hi } of fs3.ranges) {
     if (hi - lo > 8) return null;
     for (let cp = lo; cp <= hi; cp++) out.push(String.fromCodePoint(cp));
   }
@@ -5472,13 +5374,13 @@ function escapeClassChar(ch2) {
 function idPart(value) {
   return encodeURIComponent(value);
 }
-function dispatchArmIds(def, path2) {
+function dispatchArmIds(def, path3) {
   const ids = [];
-  for (const entry of def.cases) ids.push(`dispatch:${path2}/when:${entry.keys.map(idPart).join("|")}`);
+  for (const entry of def.cases) ids.push(`dispatch:${path3}/when:${entry.keys.map(idPart).join("|")}`);
   for (const entry of def.matchers ?? []) {
-    ids.push(`dispatch:${path2}/matcher:${entry.kind}:${idPart(entry.value)}${entry.kind === "matches" && entry.flags ? `:${idPart(entry.flags)}` : ""}`);
+    ids.push(`dispatch:${path3}/matcher:${entry.kind}:${idPart(entry.value)}${entry.kind === "matches" && entry.flags ? `:${idPart(entry.flags)}` : ""}`);
   }
-  if (def.otherwise) ids.push(`dispatch:${path2}/otherwise`);
+  if (def.otherwise) ids.push(`dispatch:${path3}/otherwise`);
   return ids;
 }
 function children(def, winners) {
@@ -5517,7 +5419,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;
@@ -5547,7 +5457,7 @@ function buildGrammarPlan(entry, winners) {
     }
   }
   const seen = /* @__PURE__ */ new Set();
-  const visit = (parser2, path2) => {
+  const visit = (parser2, path3) => {
     if (seen.has(parser2)) return;
     seen.add(parser2);
     const rule = winnerNames.get(parser2) ?? parser2._ruleName;
@@ -5557,22 +5467,22 @@ function buildGrammarPlan(entry, winners) {
       rules2.set(parser2, id);
     }
     if (parser2._def.tag === "choice") {
-      const ids = parser2._def.parsers.map((_, index) => `choice:${path2}/arm:${index}`);
+      const ids = parser2._def.parsers.map((_, index) => `choice:${path3}/arm:${index}`);
       choices.set(parser2, ids);
       ids.forEach((id) => definitions.set(id, { id, kind: "choice-arm" }));
     }
     if (parser2._def.tag === "dispatch") {
-      const ids = dispatchArmIds(parser2._def, path2);
+      const ids = dispatchArmIds(parser2._def, path3);
       dispatches.set(parser2, ids);
       ids.forEach((id) => definitions.set(id, { id, kind: "dispatch-arm" }));
     }
-    if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path2}`);
+    if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path3}`);
     if (parser2._def.tag === "label") {
-      const id = `label:${path2}`;
+      const id = `label:${path3}`;
       labels.set(parser2, [id]);
       definitions.set(id, { id, kind: "label" });
     }
-    children(parser2._def, winners).forEach((child, index) => visit(child, `${path2}/${parser2._def.tag}:${index}`));
+    children(parser2._def, winners).forEach((child, index) => visit(child, `${path3}/${parser2._def.tag}:${index}`));
   };
   const roots = Array.isArray(entry) ? entry : [entry];
   for (const root of roots) {
@@ -6344,10 +6254,10 @@ var ALT_SWITCH_MIN_CASES = 3;
 function planAltSwitch(firsts) {
   const cases = [];
   let total = 0;
-  for (const fs2 of firsts) {
-    if (!fs2 || fs2.negated) return { kind: "if" };
+  for (const fs3 of firsts) {
+    if (!fs3 || fs3.negated) return { kind: "if" };
     const pts = [];
-    for (const [lo, hi] of fs2.ranges) {
+    for (const [lo, hi] of fs3.ranges) {
       if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: "if" };
       for (let cp = lo; cp <= hi; cp++) pts.push(cp);
     }
@@ -6422,8 +6332,8 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
       } else {
         const c0 = codeAt(start, firstChar);
         shape.arms.forEach((arm, k) => {
-          const fs2 = shape.firsts[k];
-          const cond = fs2.negated ? `!(${classCond(c0, fs2.ranges)})` : `(${classCond(c0, fs2.ranges)})`;
+          const fs3 = shape.firsts[k];
+          const cond = fs3.negated ? `!(${classCond(c0, fs3.ranges)})` : `(${classCond(c0, fs3.ranges)})`;
           const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
           lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
           lines.push(...m.setup);
@@ -6840,27 +6750,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 }`;
 }
@@ -7043,7 +6979,30 @@ 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;
@@ -7055,6 +7014,27 @@ function endLoweringCapture() {
   _loweringSink = null;
   return misses;
 }
+var _inlineCapSink = null;
+function beginInlineCapCapture() {
+  _inlineCapSink = [];
+}
+function endInlineCapCapture() {
+  const sites = _inlineCapSink ?? [];
+  _inlineCapSink = null;
+  return sites;
+}
+function formatInlineCapSites(sites, max) {
+  if (sites.length === 0) return [];
+  const byFn = /* @__PURE__ */ new Map();
+  for (const s of sites) {
+    const cur = byFn.get(s.fn);
+    if (cur) {
+      cur.count += 1;
+      cur.nodes += s.nodes;
+    } else byFn.set(s.fn, { count: 1, nodes: s.nodes });
+  }
+  return [...byFn].map(([fn, { count, nodes }]) => `[parseman] inline-cap ${fn}: inline budget of ${max} node(s) spent \u2014 ${count} single-use ref(s) totalling ~${nodes} node(s) became called functions instead of inline bodies. Raise it with maxInline (or PARSEMAN_MAX_INLINE) if this rule is hot.`);
+}
 function hasSelectedRootTrivia(ctx) {
   return ctx.rootTriviaClassified === true;
 }
@@ -7338,10 +7318,10 @@ function ensureTriviaFn(ctx) {
 function ensureTriviaCaptureFn(ctx) {
   return ensureTriviaFn(ctx);
 }
-function firstSetCond(codeVar, fs2) {
-  if (fs2.kind === "any") return "true";
-  if (fs2.kind === "empty") return "false";
-  return fs2.ranges.map(
+function firstSetCond(codeVar, fs3) {
+  if (fs3.kind === "any") return "true";
+  if (fs3.kind === "empty") return "false";
+  return fs3.ranges.map(
     (r) => r.lo === r.hi ? `${codeVar} === ${r.lo}` : `(${codeVar} >= ${r.lo} && ${codeVar} <= ${r.hi})`
   ).join(" || ");
 }
@@ -7354,10 +7334,10 @@ function planDisjointDispatch(parsers) {
   const cases = [];
   let total = 0;
   for (const p of parsers) {
-    const fs2 = p._meta.firstSet;
-    if (fs2.kind !== "ranges") return { kind: "if" };
+    const fs3 = p._meta.firstSet;
+    if (fs3.kind !== "ranges") return { kind: "if" };
     const pts = [];
-    for (const r of fs2.ranges) {
+    for (const r of fs3.ranges) {
       if (r.hi - r.lo + 1 > SWITCH_RANGE_LIMIT) return { kind: "if" };
       for (let cp = r.lo; cp <= r.hi; cp++) pts.push(cp);
     }
@@ -7750,9 +7730,9 @@ function emitRegex(def, ctx, pos, canMatchNewline = true) {
   stmts.push(...emitLeafCapture(ctx, vv, pos, endVar));
   return { stmts, valueVar: vv, endVar };
 }
-function syncSentinelExpr(fs2) {
-  if (fs2.kind !== "ranges" || fs2.ranges.length === 0) return null;
-  return `_ctx._rec.sentinel({ kind: 'ranges', ranges: ${JSON.stringify(fs2.ranges)} })`;
+function syncSentinelExpr(fs3) {
+  if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return null;
+  return `_ctx._rec.sentinel({ kind: 'ranges', ranges: ${JSON.stringify(fs3.ranges)} })`;
 }
 function emitSeqValues(def, ctx, pos) {
   const startV = v(ctx, "_start");
@@ -7766,8 +7746,8 @@ function emitSeqValues(def, ctx, pos) {
   if (ctx.recovery) stmts.push(`${ind(ctx)}const ${syncInV} = _ctx._sync`);
   const publishSync = (i) => {
     if (!ctx.recovery) return "";
-    const fs2 = def.parsers.slice(i + 1).reduce((acc, p) => union(acc, firstSetOf(p)), { kind: "empty" });
-    const ref2 = syncSentinelExpr(fs2);
+    const fs3 = def.parsers.slice(i + 1).reduce((acc, p) => union(acc, firstSetOf(p)), { kind: "empty" });
+    const ref2 = syncSentinelExpr(fs3);
     return `${ind(ctx)}if (_ctx._tolerant) _ctx._sync = ${ref2 ?? syncInV}`;
   };
   for (let i = 0; i < def.parsers.length; i++) {
@@ -7803,9 +7783,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)
@@ -7815,7 +7797,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;
@@ -7881,8 +7863,8 @@ function canMatchEmptyAtStart(p) {
   }
 }
 function needsFirstSetGuard(p) {
-  const fs2 = p._meta.firstSet;
-  return fs2.kind !== "any" && !canMatchEmptyAtStart(p);
+  const fs3 = p._meta.firstSet;
+  return fs3.kind !== "any" && !canMatchEmptyAtStart(p);
 }
 function coverageHit(ctx, id, offset = "_pos", end) {
   return id === void 0 ? [] : [
@@ -8887,9 +8869,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)),
@@ -8900,9 +8891,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`)
     ],
@@ -8910,6 +8911,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, "\\$&");
 }
@@ -9091,22 +9116,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";
@@ -9115,7 +9134,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);
@@ -9126,7 +9145,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` : ""}`
@@ -9143,21 +9161,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");
@@ -9181,19 +9191,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) {
@@ -9222,7 +9235,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}`;
@@ -9237,6 +9255,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;
@@ -9251,6 +9272,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);
@@ -9345,6 +9368,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;
@@ -9352,6 +9378,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));
   }
@@ -9545,7 +9573,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":
@@ -9580,6 +9608,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;
@@ -9587,6 +9618,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);
@@ -9745,12 +9778,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 [];
   }
@@ -9771,6 +9808,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]);
 }
@@ -9876,102 +9924,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;
@@ -10014,7 +9966,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;
@@ -10022,9 +9984,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: [],
@@ -10070,11 +10035,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,
@@ -10089,6 +10056,7 @@ function compile(combinator, mapFnSources, opts) {
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
     ...hostReadsDecls,
+    ...rawEntryDecls,
     ...lineTrackDecls,
     ...lineSpanDecls,
     ...ctx.regexDecls,
@@ -10138,8 +10106,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 {
@@ -10204,7 +10171,6 @@ function publicRuleWrapperSource(rule, fnSource, ambientTriviaKindLabels, ambien
   return `Object.assign(${fnSource}, { _meta: {${labels === void 0 ? "" : ` triviaKindLabels: ${JSON.stringify(labels)},`}${classified === void 0 ? "" : " rootTriviaClassified: true,"} } })`;
 }
 function compileRuleMap(ruleMap, opts) {
-  runGatingDiagnosticRules(ruleMap, opts?.gating);
   runDuplicationDiagnosticRules(ruleMap, opts?.duplication);
   for (const [, rule] of ruleMap) markUnusedValues(rule);
   const coverageWinners = opts?.coverage ? Object.fromEntries(ruleMap.filter(([, rule]) => rule._def.tag !== "lazy")) : void 0;
@@ -10213,9 +10179,12 @@ function compileRuleMap(ruleMap, opts) {
   const grammarScanSkip = opts?.scanSkip ?? ruleMap.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
   const grammarTrackLines = opts?.trackLines === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
+  const _inlineMax = resolveInlineMax(opts?.maxInline);
   const ctx = {
     vars: 0,
     indent: 1,
+    inlineMax: _inlineMax,
+    inlineLeft: _inlineMax,
     regexDecls: [],
     regexMap: /* @__PURE__ */ new Map(),
     expectedDecls: [],
@@ -10281,6 +10250,7 @@ function compileRuleMap(ruleMap, opts) {
   const hoistedDecls = [
     ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
     ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "",
+    ctx.needsRawEntry ? `  ${RAW_ENTRY_DECL}` : "",
     ctx.needsLineTrack ? `  ${LINE_TRACK_DECL}` : "",
     ctx.needsLineSpan ? `  ${LINE_SPAN_DECL}` : "",
     ...ctx.regexDecls.map((d) => `  ${d}`),
@@ -10353,7 +10323,6 @@ function compileRuleMap(ruleMap, opts) {
 }
 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);
@@ -10372,9 +10341,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: [],
@@ -10470,6 +10442,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;
@@ -10485,6 +10460,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)})`,
@@ -10569,6 +10546,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)),
@@ -10643,14 +10621,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}`),
@@ -10720,18 +10700,19 @@ 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":
       return [];
   }
 }
-var ruleNameOf4 = (c) => c._ruleName;
+var ruleNameOf3 = (c) => c._ruleName;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
   try {
@@ -10806,7 +10787,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(", ")}`);
     }
@@ -10815,6 +10796,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) => {
@@ -10967,7 +10949,7 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf3(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
@@ -10978,7 +10960,7 @@ var Serializer = class {
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
   body(c) {
-    return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
+    return c._def.tag === "lazy" && ruleNameOf3(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
@@ -11020,7 +11002,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
-      if (ruleNameOf4(c) !== void 0) return;
+      if (ruleNameOf3(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
       if (active.has(target)) {
@@ -11072,7 +11054,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     const kid = (x) => this.ref(x, selfOf);
     switch (def.tag) {
       case "lazy": {
-        const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
+        const name = this.localRuleNames.get(c) ?? ruleNameOf3(c);
         if (name !== void 0) return `g[${JSON.stringify(name)}]`;
         const target = lazyTarget(c);
         if (selfOf && target === selfOf.comb) return selfOf.var;
@@ -11127,7 +11109,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":
@@ -11160,6 +11142,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(", ")} }` : "";
@@ -11168,8 +11153,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)})`;
       }
@@ -11257,12 +11248,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).
@@ -11296,8 +11289,8 @@ function fusedBody(pieces) {
   for (const [k, p] of winner) {
     const r = p.firstSetRecipes?.get(k);
     if (r) recipes.set(k, r);
-    const fs2 = p.firstSets?.get(k);
-    if (fs2) shallow.set(k, fs2);
+    const fs3 = p.firstSets?.get(k);
+    if (fs3) shallow.set(k, fs3);
     const nu = p.nullable?.get(k);
     if (nu !== void 0) nullable2.set(k, nu);
   }
@@ -11320,9 +11313,9 @@ function fusedBody(pieces) {
   for (let iter = 0; iter <= recipes.size; iter++) {
     let changed = false;
     for (const [k, r] of recipes) {
-      const fs2 = resolveRecipe(r);
-      if (JSON.stringify(finalFS.get(k)) !== JSON.stringify(fs2)) {
-        finalFS.set(k, fs2);
+      const fs3 = resolveRecipe(r);
+      if (JSON.stringify(finalFS.get(k)) !== JSON.stringify(fs3)) {
+        finalFS.set(k, fs3);
         changed = true;
       }
     }
@@ -11334,9 +11327,9 @@ function fusedBody(pieces) {
     // matches every well-formed placeholder.
     /\/\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\*\/true/g,
     (_m, name, codevar) => {
-      const fs2 = finalFS.get(name);
-      if (!fs2 || fs2.kind === "any" || fs2.kind === "empty") return "true";
-      return `(${firstSetCond(codevar, fs2)})`;
+      const fs3 = finalFS.get(name);
+      if (!fs3 || fs3.kind === "any" || fs3.kind === "empty") return "true";
+      return `(${firstSetCond(codevar, fs3)})`;
     }
   );
   const env = {};
@@ -11368,17 +11361,6 @@ ${body}
 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 materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   if (!isIRPiece(p)) return p;
   const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
@@ -11410,8 +11392,22 @@ function gate(predicate) {
   };
 }
 
-// src/cst/offset-model.ts
-var { isFinite } = Number;
+// 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\`.`
+  ]
+];
 
 // src/index.ts
 registerRegexAnalyzer(firstSetFromRegex);
@@ -11605,6 +11601,10 @@ function stripTsFromSource(node2, code) {
   }
   return out + code.slice(cur, end);
 }
+var _reducers = null;
+function setReducerResolver(r) {
+  _reducers = r;
+}
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
 }
@@ -11836,9 +11836,12 @@ function staticNodeOptionsFromValue(value) {
     } else if (name === "tags") {
       if (!Array.isArray(v2) || !v2.every((item) => typeof item === "string")) return STATIC_NODE_OPTIONS_FAILED;
       opts.tags = v2;
+    } else if (name === "buildArity") {
+      if (typeof v2 !== "number" || !Number.isInteger(v2) || v2 < 0 || v2 > 6) return STATIC_NODE_OPTIONS_FAILED;
+      opts.buildArity = v2;
     }
   }
-  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 || opts.buildArity !== void 0 ? opts : void 0;
 }
 function staticNodeOptions(expr, scope) {
   const unwrapped = unwrapStaticExpr(expr);
@@ -11864,9 +11867,13 @@ function staticNodeOptions(expr, scope) {
       const tags = staticStringArray(p.value, scope);
       if (tags === void 0) return STATIC_NODE_OPTIONS_FAILED;
       opts.tags = tags;
+    } else if (name === "buildArity") {
+      const arity = staticLiteralValue(p.value);
+      if (typeof arity !== "number" || !Number.isInteger(arity) || arity < 0 || arity > 6) return STATIC_NODE_OPTIONS_FAILED;
+      opts.buildArity = arity;
     }
   }
-  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 || opts.buildArity !== void 0 ? opts : void 0;
 }
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
@@ -11962,6 +11969,15 @@ function exprToCombi(node2, scope, code, mfs) {
       const combi = explicitType !== void 0 ? node(explicitType, inner, hasBuild ? () => null : void 0, opts) : node(inner, hasBuild ? () => null : void 0, opts);
       if (combi._def.tag === "node" && buildSrc !== void 0) {
         combi._def.buildSrc = buildSrc;
+        if (explicitType !== void 0 && firstArg.type === "Identifier") {
+          combi._def.typeSrc = firstArg.name;
+        }
+        const resolved = _reducers?.resolve(buildSrc, be.start, code);
+        if (resolved) {
+          if (resolved.src !== null) combi._def.buildSigSrc = resolved.src;
+          if (combi._def.buildArity === void 0 && resolved.arity !== null) combi._def.buildArity = resolved.arity;
+          if (resolved.reason !== void 0) combi._def.buildArityUnresolved = resolved.reason;
+        }
         const staticError = directBuilderUnsupportedBindings(buildSrc);
         if (staticError.length > 0) combi._def.buildStaticError = staticError;
       }
@@ -12379,9 +12395,9 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
     r._ruleName = name;
     if (r._def.tag === "node" && r._def.type === void 0) r._def.type = name;
   };
-  const ruleNameOf5 = (r) => r._ruleName;
+  const ruleNameOf4 = (r) => r._ruleName;
   const isNamedRuleRefForAnotherRule2 = (r, key) => {
-    const name = r._def.tag === "lazy" ? ruleNameOf5(r) : void 0;
+    const name = r._def.tag === "lazy" ? ruleNameOf4(r) : void 0;
     return name !== void 0 && name !== key;
   };
   for (const key of keys) {
@@ -12472,6 +12488,367 @@ function referencesAny(node2, names, scope) {
   return false;
 }
 
+// src/plugin/reducer-resolver.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createRequire } from "node:module";
+import { parseSync as parseSync2 } from "oxc-parser";
+var FUNCTION_TYPES = /* @__PURE__ */ new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+var SCOPE_TYPES = /* @__PURE__ */ new Set([
+  ...FUNCTION_TYPES,
+  "BlockStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "CatchClause",
+  "ClassDeclaration",
+  "ClassExpression",
+  "StaticBlock"
+]);
+function newScope(start, end, parent, isFunction) {
+  const s = { start, end, bindings: /* @__PURE__ */ new Map(), children: [], parent, isFunction };
+  parent?.children.push(s);
+  return s;
+}
+function patternNames(pat, out) {
+  if (!pat || typeof pat !== "object") return;
+  const n = pat;
+  switch (n.type) {
+    case "Identifier":
+      out.push(n.name);
+      return;
+    case "AssignmentPattern":
+      return patternNames(n.left, out);
+    case "RestElement":
+      return patternNames(n.argument, out);
+    case "ArrayPattern":
+      for (const el of n.elements ?? []) patternNames(el, out);
+      return;
+    case "ObjectPattern":
+      for (const p of n.properties ?? []) patternNames(p.type === "RestElement" ? p.argument : p.value, out);
+      return;
+    // A TS parameter property / assignment target wrapper.
+    case "TSParameterProperty":
+      return patternNames(n.parameter, out);
+    default:
+      return;
+  }
+}
+function declare(scope, name, b) {
+  if (!scope.bindings.has(name)) scope.bindings.set(name, b);
+}
+function functionScope(scope) {
+  let s = scope;
+  while (!s.isFunction && s.parent) s = s.parent;
+  return s;
+}
+function buildScopeTree(body, moduleEnd) {
+  const root = newScope(0, moduleEnd, null, true);
+  const declarePattern = (scope, pat, kind, init) => {
+    const names = [];
+    patternNames(pat, names);
+    const target = kind === "var" ? functionScope(scope) : scope;
+    for (const name of names) {
+      declare(target, name, init !== void 0 && names.length === 1 ? { kind, init } : { kind });
+    }
+  };
+  const walk = (n, scope) => {
+    if (!n || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      for (const item of n) walk(item, scope);
+      return;
+    }
+    const node2 = n;
+    if (typeof node2.type !== "string") return;
+    switch (node2.type) {
+      case "VariableDeclaration": {
+        const kind = node2.kind ?? "var";
+        for (const d of node2.declarations ?? []) {
+          declarePattern(scope, d.id, kind, d.init ?? void 0);
+        }
+        break;
+      }
+      case "FunctionDeclaration":
+        if (node2.id) declare(functionScope(scope), node2.id.name, { kind: "function", init: node2 });
+        break;
+      case "ClassDeclaration":
+        if (node2.id) declare(scope, node2.id.name, { kind: "class" });
+        break;
+      case "ImportDeclaration": {
+        const specifier = node2.source?.value ?? "";
+        for (const sp of node2.specifiers ?? []) {
+          const local = sp.local?.name;
+          if (!local) continue;
+          const imported = sp.type === "ImportDefaultSpecifier" ? "default" : sp.type === "ImportNamespaceSpecifier" ? "*" : sp.imported?.name ?? local;
+          declare(scope, local, { kind: "import", importRef: { specifier, imported } });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (SCOPE_TYPES.has(node2.type)) {
+      const isFn = FUNCTION_TYPES.has(node2.type);
+      const inner = newScope(node2.start, node2.end, scope, isFn);
+      if (isFn) {
+        for (const p of node2.params ?? []) declarePattern(inner, p, "param");
+        if (node2.type === "FunctionExpression" && node2.id) {
+          declare(inner, node2.id.name, { kind: "function", init: node2 });
+        }
+      }
+      if (node2.type === "CatchClause" && node2.param) declarePattern(inner, node2.param, "catch");
+      for (const key of Object.keys(node2)) {
+        if (key === "type" || key === "start" || key === "end") continue;
+        walk(node2[key], inner);
+      }
+      return;
+    }
+    for (const key of Object.keys(node2)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      walk(node2[key], scope);
+    }
+  };
+  for (const stmt of body) walk(stmt, root);
+  return root;
+}
+function scopeAt(root, offset) {
+  let cur = root;
+  for (; ; ) {
+    const next = cur.children.find((c) => offset >= c.start && offset <= c.end);
+    if (!next) return cur;
+    cur = next;
+  }
+}
+function lookup(scope, name) {
+  for (let s = scope; s; s = s.parent) {
+    const b = s.bindings.get(name);
+    if (b) return { binding: b, scope: s };
+  }
+  return null;
+}
+function markReassignments(body, root) {
+  const walk = (n) => {
+    if (!n || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      for (const item of n) walk(item);
+      return;
+    }
+    const node2 = n;
+    if (typeof node2.type !== "string") return;
+    if (node2.type === "AssignmentExpression" || node2.type === "UpdateExpression") {
+      const target = node2.type === "UpdateExpression" ? node2.argument : node2.left;
+      const names = [];
+      if (target) patternNames(target, names);
+      for (const name of names) {
+        const hit = lookup(scopeAt(root, node2.start), name);
+        if (hit) hit.binding.reassigned = true;
+      }
+    }
+    for (const key of Object.keys(node2)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      walk(node2[key]);
+    }
+  };
+  for (const stmt of body) walk(stmt);
+}
+function functionArity(fn) {
+  const params = fn.params ?? [];
+  let count = 0;
+  for (const p of params) {
+    if (p.type === "RestElement") return { arity: null, reason: "rest-parameter" };
+    if (p.type === "Identifier" && p.name === "this") continue;
+    count++;
+  }
+  if (fn.type !== "ArrowFunctionExpression" && referencesArguments(fn.body)) {
+    return { arity: null, reason: "arguments" };
+  }
+  return { arity: count };
+}
+function referencesArguments(n) {
+  if (!n || typeof n !== "object") return false;
+  if (Array.isArray(n)) return n.some(referencesArguments);
+  const node2 = n;
+  if (typeof node2.type !== "string") return false;
+  if (node2.type === "Identifier" && node2.name === "arguments") return true;
+  if (node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression") return false;
+  for (const key of Object.keys(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (referencesArguments(node2[key])) return true;
+  }
+  return false;
+}
+var _moduleCache = /* @__PURE__ */ new Map();
+function analyseModuleFile(file) {
+  let mtimeMs;
+  try {
+    mtimeMs = fs.statSync(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = _moduleCache.get(file);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.mod;
+  let mod = null;
+  try {
+    const src = fs.readFileSync(file, "utf8");
+    const r = parseSync2(file, src);
+    if (r.errors.length === 0) {
+      const body = r.program.body;
+      const scopes = buildScopeTree(body, src.length);
+      markReassignments(body, scopes);
+      mod = { file, src, body, scopes };
+    }
+  } catch {
+  }
+  _moduleCache.set(file, { mtimeMs, mod });
+  return mod;
+}
+var SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".mjs", ".cjs", ".jsx"];
+function resolveImport(fromFile, specifier) {
+  if (specifier.startsWith(".") || path.isAbsolute(specifier)) {
+    const base = path.resolve(path.dirname(fromFile), specifier);
+    const ext = path.extname(base);
+    const stem = ext ? base.slice(0, -ext.length) : base;
+    const candidates = [
+      ...ext ? [base] : [],
+      // `./x.js` in TS source usually means `./x.ts`.
+      ...SOURCE_EXTS.map((e) => `${stem}${e}`),
+      ...SOURCE_EXTS.map((e) => path.join(base, `index${e}`))
+    ];
+    for (const c of candidates) {
+      try {
+        if (fs.statSync(c).isFile()) return fs.realpathSync(c);
+      } catch {
+      }
+    }
+    return null;
+  }
+  try {
+    return fs.realpathSync(createRequire(fromFile).resolve(specifier));
+  } catch {
+    return null;
+  }
+}
+function declarationBinds(decl, name) {
+  if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") {
+    return decl.id?.name === name;
+  }
+  if (decl.type === "VariableDeclaration") {
+    const names = [];
+    for (const d of decl.declarations ?? []) patternNames(d.id, names);
+    return names.includes(name);
+  }
+  return false;
+}
+function exportedBinding(mod, name, seen) {
+  for (const stmt of mod.body) {
+    if (stmt.type === "ExportDefaultDeclaration" && name === "default") {
+      const d = stmt.declaration;
+      if (FUNCTION_TYPES.has(d.type)) return { mod, binding: { kind: "const", init: d } };
+      if (d.type === "Identifier") {
+        const hit2 = lookup(mod.scopes, d.name);
+        return hit2 ? { mod, binding: hit2.binding } : null;
+      }
+      return null;
+    }
+    if (stmt.type === "ExportNamedDeclaration") {
+      const decl = stmt.declaration;
+      if (decl && declarationBinds(decl, name)) {
+        const hit2 = lookup(mod.scopes, name);
+        if (hit2 && hit2.scope === mod.scopes) return { mod, binding: hit2.binding };
+      }
+      for (const sp of stmt.specifiers ?? []) {
+        const exported = sp.exported?.name ?? "";
+        if (exported !== name) continue;
+        const local = sp.local?.name ?? exported;
+        const from = stmt.source?.value;
+        if (from !== void 0) return followReExport(mod, from, local, seen);
+        const hit2 = lookup(mod.scopes, local);
+        return hit2 ? { mod, binding: hit2.binding } : null;
+      }
+    }
+    if (stmt.type === "ExportAllDeclaration" && !stmt.exported) {
+      const from = stmt.source?.value;
+      if (from === void 0) continue;
+      const found = followReExport(mod, from, name, seen);
+      if (found) return found;
+    }
+  }
+  const hit = lookup(mod.scopes, name);
+  return hit && hit.scope === mod.scopes ? { mod, binding: hit.binding } : null;
+}
+function followReExport(mod, specifier, name, seen) {
+  const file = resolveImport(mod.file, specifier);
+  if (!file || seen.has(`${file}\0${name}`)) return null;
+  seen.add(`${file}\0${name}`);
+  const next = analyseModuleFile(file);
+  return next ? exportedBinding(next, name, seen) : null;
+}
+var MAX_HOPS = 12;
+var IDENT_RE = /^[A-Za-z_$][\w$]*$/;
+var MEMBER_RE = /^([A-Za-z_$][\w$]*)\s*\.\s*([A-Za-z_$][\w$]*)$/;
+function createReducerResolver(entryFile, body, src) {
+  const scopes = buildScopeTree(body, src.length);
+  markReassignments(body, scopes);
+  const entry = { file: entryFile, src, body, scopes };
+  const fromBinding = (mod, binding, memberName, hops, seen) => {
+    if (hops > MAX_HOPS) return { arity: null, src: null, reason: "not-found" };
+    if (binding.reassigned) return { arity: null, src: null, reason: "reassigned" };
+    if (binding.kind === "param" || binding.kind === "catch" || binding.kind === "class") {
+      return { arity: null, src: null, reason: "not-a-function" };
+    }
+    if (binding.kind === "import" && binding.importRef) {
+      const { specifier, imported } = binding.importRef;
+      if (imported === "*" && memberName === void 0) return { arity: null, src: null, reason: "not-a-function" };
+      const file = resolveImport(mod.file, specifier);
+      if (!file) return { arity: null, src: null, reason: "unresolved-import" };
+      const next = analyseModuleFile(file);
+      if (!next) return { arity: null, src: null, reason: "unresolved-import" };
+      const wanted = imported === "*" ? memberName : imported;
+      if (wanted === void 0) return { arity: null, src: null, reason: "not-a-function" };
+      const found = exportedBinding(next, wanted, seen);
+      if (!found) return { arity: null, src: null, reason: "not-found" };
+      return fromBinding(found.mod, found.binding, void 0, hops + 1, seen);
+    }
+    const init = binding.init;
+    if (!init) return { arity: null, src: null, reason: "not-a-function" };
+    if (init.type === "Identifier") {
+      const hit = lookup(scopeAt(mod.scopes, init.start), init.name);
+      if (!hit) return { arity: null, src: null, reason: "not-found" };
+      return fromBinding(mod, hit.binding, void 0, hops + 1, seen);
+    }
+    if (init.type === "ComputedMemberExpression" || init.computed === true && init.type.endsWith("MemberExpression")) {
+      return { arity: null, src: null, reason: "computed" };
+    }
+    if (init.type === "StaticMemberExpression" || init.type === "MemberExpression") {
+      const obj = init.object;
+      const prop = init.property;
+      if (obj?.type === "Identifier" && prop?.type === "Identifier") {
+        const hit = lookup(scopeAt(mod.scopes, init.start), obj.name);
+        if (!hit) return { arity: null, src: null, reason: "not-found" };
+        return fromBinding(mod, hit.binding, prop.name, hops + 1, seen);
+      }
+      return { arity: null, src: null, reason: "computed" };
+    }
+    if (!FUNCTION_TYPES.has(init.type)) return { arity: null, src: null, reason: "not-a-function" };
+    const { arity, reason } = functionArity(init);
+    return { arity, src: mod.src.slice(init.start, init.end), ...reason ? { reason } : {} };
+  };
+  return {
+    resolve(exprSrc, offset, offsetSrc) {
+      const text = exprSrc.trim();
+      const ident = IDENT_RE.test(text) ? text : null;
+      const member = ident ? null : MEMBER_RE.exec(text);
+      if (!ident && !member) return null;
+      if (offsetSrc !== src) return { arity: null, src: null, reason: "foreign-source" };
+      const name = ident ?? member[1];
+      const memberName = ident ? void 0 : member[2];
+      const hit = lookup(scopeAt(scopes, offset), name);
+      if (!hit) return { arity: null, src: null, reason: "not-found" };
+      return fromBinding(entry, hit.binding, memberName, 0, /* @__PURE__ */ new Set());
+    }
+  };
+}
+
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var PARSEMAN_MODULE = "parseman";
@@ -12497,37 +12874,37 @@ function getCompiledResolver() {
 }
 var PRIVATE_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts"]);
 function nearestPackageRoot(file) {
-  let dir = path.dirname(file);
+  let dir = path2.dirname(file);
   for (; ; ) {
     try {
-      if (fs.statSync(path.join(dir, "package.json")).isFile()) return fs.realpathSync(dir);
+      if (fs2.statSync(path2.join(dir, "package.json")).isFile()) return fs2.realpathSync(dir);
     } catch {
     }
-    const parent = path.dirname(dir);
+    const parent = path2.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function isWithinPackageRoot(file, root) {
-  const relative2 = path.relative(root, file);
-  return relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2);
+  const relative2 = path2.relative(root, file);
+  return relative2 !== ".." && !relative2.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative2);
 }
 function resolvePrivateSourceModule(from, specifier) {
-  if (!specifier.startsWith(".") && !path.isAbsolute(specifier)) return null;
+  if (!specifier.startsWith(".") && !path2.isAbsolute(specifier)) return null;
   const packageRoot = nearestPackageRoot(from);
   if (!packageRoot) return null;
-  const base = path.resolve(path.dirname(from), specifier);
-  const ext = path.extname(base);
+  const base = path2.resolve(path2.dirname(from), specifier);
+  const ext = path2.extname(base);
   const candidates = [
     base,
     ...ext ? [".ts", ".tsx", ".mts", ".cts"].map((next) => `${base.slice(0, -ext.length)}${next}`) : [],
     ...!ext ? [".ts", ".tsx", ".mts", ".cts"].map((next) => `${base}${next}`) : [],
-    ...!ext ? ["index.ts", "index.tsx", "index.mts", "index.cts"].map((next) => path.join(base, next)) : []
+    ...!ext ? ["index.ts", "index.tsx", "index.mts", "index.cts"].map((next) => path2.join(base, next)) : []
   ];
   for (const candidate of candidates) {
     try {
-      if (!fs.statSync(candidate).isFile()) continue;
-      const real = fs.realpathSync(candidate);
+      if (!fs2.statSync(candidate).isFile()) continue;
+      const real = fs2.realpathSync(candidate);
       if (isWithinPackageRoot(real, packageRoot)) return real;
     } catch {
     }
@@ -12535,7 +12912,7 @@ function resolvePrivateSourceModule(from, specifier) {
   return null;
 }
 function resolveGrammarModule(from, specifier) {
-  if (PRIVATE_SOURCE_EXTENSIONS.has(path.extname(specifier))) {
+  if (PRIVATE_SOURCE_EXTENSIONS.has(path2.extname(specifier))) {
     const file2 = resolvePrivateSourceModule(from, specifier);
     return file2 ? { file: file2, source: true } : null;
   }
@@ -12556,7 +12933,7 @@ var _moduleParseCache = /* @__PURE__ */ new Map();
 function parseModuleCached(filePath) {
   let mtimeMs;
   try {
-    mtimeMs = fs.statSync(filePath).mtimeMs;
+    mtimeMs = fs2.statSync(filePath).mtimeMs;
   } catch {
     return null;
   }
@@ -12564,8 +12941,8 @@ function parseModuleCached(filePath) {
   if (hit && hit.mtimeMs === mtimeMs) return hit.parsed;
   let parsed = null;
   try {
-    const src = fs.readFileSync(filePath, "utf8");
-    const r = parseSync2(filePath, src);
+    const src = fs2.readFileSync(filePath, "utf8");
+    const r = parseSync3(filePath, src);
     if (r.errors.length === 0) parsed = { body: r.program.body, src };
   } catch {
   }
@@ -12693,7 +13070,7 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
   if (_sourceLowering.has(file)) return null;
   let mtimeMs;
   try {
-    mtimeMs = fs.statSync(file).mtimeMs;
+    mtimeMs = fs2.statSync(file).mtimeMs;
   } catch {
     return null;
   }
@@ -12703,10 +13080,10 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
   _sourceLowering.add(file);
   let parsedModule = null;
   try {
-    const source = fs.readFileSync(file, "utf8");
+    const source = fs2.readFileSync(file, "utf8");
     const transformed = transformMacro(source, file, moduleAliases, warnUnloweredRegex, recovery);
     if (!transformed || transformed.warnings.length > 0) return null;
-    const parsed = parseSync2(file, transformed.code);
+    const parsed = parseSync3(file, transformed.code);
     parsedModule = parsed.errors.length === 0 ? { body: parsed.program.body, src: transformed.code } : null;
     return parsedModule;
   } catch {
@@ -12717,9 +13094,20 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
   }
 }
 function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false) {
+  const depth = degradationCaptureDepth();
+  try {
+    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage);
+  } finally {
+    setReducerResolver(null);
+    endLoweringCapture();
+    endInlineCapCapture();
+    for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d));
+  }
+}
+function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage) {
   let result;
   try {
-    result = parseSync2(id, code);
+    result = parseSync3(id, code);
   } catch {
     return null;
   }
@@ -12776,6 +13164,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
     }
   }
+  setReducerResolver(createReducerResolver(id, body, code));
   const topLevelFunction = (moduleBody, name) => {
     for (const st of moduleBody) {
       const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
@@ -12875,6 +13264,8 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const replacements = [];
   const warnings = [];
   beginLoweringCapture();
+  beginInlineCapCapture();
+  beginDegradationCapture();
   let anyUnresolved = false;
   let keepMacroImport = false;
   let runtimeComposeFallback = false;
@@ -12990,7 +13381,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const mapLit = (m, stripVals = false) => `new Map([${[...m].map(
       ([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(stripVals && typeof v2 === "string" ? stripIndent(v2) : v2)}]`
     ).join(", ")}])`;
-    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, nodeMeta: ${mapLit(p.nodeMeta)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
+    return `{ v: ${JSON.stringify(p.v)}, ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, nodeMeta: ${mapLit(p.nodeMeta)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, needsRawEntry: ${p.needsRawEntry}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
   };
   const isSpread = (it) => "__spreadLocal" in it;
   const isIR = (it) => "ir" in it && !("ruleFns" in it);
@@ -13001,9 +13392,19 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const withHostMode = (grammarExpr, mode, elided) => `/* @__PURE__ */ (m => { for (const k of Object.keys(m)) { Object.defineProperty(m[k], Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m[k], Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }) } Object.defineProperty(m, Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m, Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }); return m })(${grammarExpr})`;
   const withGrammarReflection = (grammarExpr, reflection) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`;
   const withCoverageDefinitions = (grammarExpr, definitions) => !grammarCoverage ? grammarExpr : `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarCoverageDefinitions'), { value: Object.freeze(${JSON.stringify(definitions)}.map(Object.freeze)), enumerable: false })`;
-  const emittedCoverageDefinitions = (source) => {
+  const emittedCoverageDefinitions = (source, where) => {
     const ids = /* @__PURE__ */ new Set();
     for (const match of source.matchAll(/id:\s*"([^"]+)"/g)) ids.add(match[1]);
+    if (grammarCoverage && ids.size === 0) {
+      recordDegradation({
+        code: "coverage-definitions-unavailable",
+        severity: "warn",
+        where,
+        subject: "generated coverage hooks",
+        fellBackTo: "no coverage definitions could be read out of the generated source, so the grammar carries an EMPTY definition set \u2014 which is no measurement, not full coverage",
+        otherwise: "the emitted hook IDs would form the coverage denominator"
+      });
+    }
     return [...ids].sort().map((id2) => ({
       id: id2,
       kind: id2.startsWith("rule:") ? "rule" : id2.startsWith("label:") ? "label" : id2.startsWith("dispatch:") ? "dispatch-arm" : "choice-arm"
@@ -13072,26 +13473,6 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     return out;
   };
-  const carriedRuleMapsDetailed = (items) => {
-    const maps = [];
-    const opaque = [];
-    const add = (it) => {
-      if (isIR(it)) {
-        maps.push(evalRuleMapIR(it.ir));
-        return;
-      }
-      const o = it;
-      opaque.push({
-        ns: o.ns ?? "<unknown>",
-        ruleNames: o.ruleFns instanceof Map ? [...o.ruleFns.keys()] : []
-      });
-    };
-    for (const it of items) {
-      if (isSpread(it)) for (const p of importedPieces(it.__spreadLocal) ?? []) add(p);
-      else add(it);
-    }
-    return { maps, opaque };
-  };
   const materializeLeafCoverage = (items, localRules, localNs, composing, captureTerminals = false) => {
     const sources = [];
     const add = (item) => {
@@ -13242,12 +13623,6 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       carried.push(...r.carried);
       importedFactories.push(...r.importedFactories ?? []);
     }
-    const detailed = once(() => carriedRuleMapsDetailed(carried));
-    runFusedGatingDiagnostic(
-      () => detailed().maps,
-      void 0,
-      () => detailed().opaque
-    );
     const pieces = materializeCarried(carried, composing, false, cHostMode);
     try {
       return {
@@ -13304,12 +13679,6 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     try {
       const localNs = nsFor(`composeLeaf${init.start}`);
-      const detailedLeaf = once(() => carriedRuleMapsDetailed(carried));
-      runFusedGatingDiagnostic(
-        () => [...detailedLeaf().maps, [...localRules]],
-        void 0,
-        () => detailedLeaf().opaque
-      );
       const plainLocalPiece = compileLinkable([...localRules], localNs, { ...composing ? { trivia: composing } : {}, ...localScanSkip ? { scanSkip: localScanSkip } : {}, recovery });
       if (!plainLocalPiece) {
         warn(init.start, "composeLeaf(): local rules could not be statically compiled");
@@ -13327,7 +13696,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
       const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece]));
       return {
-        replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)),
+        replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement, `${id} composeLeaf()`)),
         ...importedFactories.length ? { importedFactories } : {}
       };
     } catch (e) {
@@ -13407,7 +13776,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
           if (refCombi) {
-            const compiled2 = compile(refCombi, void 0, { recovery, coverage: grammarCoverage, gating: { entryName: varName } });
+            const compiled2 = compile(refCombi, void 0, { recovery, coverage: grammarCoverage });
             if (compiled2.inlineExpression === null) {
               warn(init.start, `"${varName}" is a ref() that couldn't be inlined (was .define() called with a static combinator?)`);
               continue;
@@ -13438,7 +13807,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const source = compiledRules.replacement ?? code.slice(init.start, init.end);
           let replacement = withCoverageDefinitions(
             source,
-            compiledRules.coverageDefinitions?.length ? compiledRules.coverageDefinitions : emittedCoverageDefinitions(source)
+            compiledRules.coverageDefinitions?.length ? compiledRules.coverageDefinitions : emittedCoverageDefinitions(source, `${id} rules()`)
           );
           if (compiledRules.replacement !== null) {
             replacement = withHostMode(replacement, compiledRules.hostMode, compiledRules.hostBranchElided);
@@ -13463,7 +13832,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           localComposedCarried.set(varName, fused.carried);
           if (fused.trivia) localComposedTrivia.set(varName, fused.trivia);
           const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.carried) : fused.replacement;
-          replacements.push({ start: init.start, end: init.end, replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) });
+          replacements.push({ start: init.start, end: init.end, replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement, `${id} compose()`)) });
           markUsedImportedFactories(fused.importedFactories);
           continue;
         }
@@ -13514,7 +13883,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }
-        const compiled = compile(parser2, void 0, { recovery, coverage: grammarCoverage, gating: { entryName: varName } });
+        const compiled = compile(parser2, void 0, { recovery, coverage: grammarCoverage });
         if (compiled.inlineExpression === null) {
           warn(init.start, `"${varName}" couldn't be inlined (likely closes over a runtime value)`);
           continue;
@@ -13640,12 +14009,23 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
 `
     );
   }
+  for (const line of formatInlineCapSites(endInlineCapCapture(), resolveInlineMax())) warnings.push(`${id}: ${line}`);
   const unlowered = endLoweringCapture();
   if (warnUnloweredRegex) {
     for (const src of unlowered) {
       warnings.push(`${id}: regex ${src} did not lower to a fast charCodeAt scan (RegExp.exec fallback)`);
     }
   }
+  setReducerResolver(null);
+  const degradations = endDegradationCapture();
+  if (degradations.length > 0) {
+    const lines = formatDegradations(degradations);
+    if (resolveDegradationLevel() === "error") {
+      throw new Error(`parseman: ${degradations.length} degraded compilation path(s) in ${id}
+${lines.join("\n")}`);
+    }
+    for (const l of lines) warnings.push(`${id}: ${l}`);
+  }
   return {
     code: ms.toString(),
     map: ms.generateMap({ hires: true }),