parseman 0.60.6 → 0.61.1

package/dist/analysis/diagnostics.js

@@ -424,13 +424,13 @@ function caseFoldVariants(cp) {
 // src/combinators/probe.ts
 function failAt(ctx, expected, pos) {
   const r = { ok: false, expected, span: { start: pos, end: pos } };
-  const probe = ctx._probe;
-  if (probe !== void 0 && pos <= probe.offset) {
-    const best = probe.best;
+  const probe2 = ctx._probe;
+  if (probe2 !== void 0 && pos <= probe2.offset) {
+    const best = probe2.best;
     if (best === null || pos > best.span.start) {
-      probe.best = r;
+      probe2.best = r;
     } else if (pos === best.span.start) {
-      probe.best = { ...best, expected: [...best.expected, ...expected] };
+      probe2.best = { ...best, expected: [...best.expected, ...expected] };
     }
   }
   return r;
@@ -2258,15 +2258,20 @@ function markUnusedValues(root) {
       case "many":
       case "oneOrMore":
         mark(def, consumed);
-        visit(def.parser, consumed);
-        return;
       case "optional":
+      // `optional` returns `inner | null` — no aggregate array/tuple to elide, so
+      // it carries no valueUnused flag. Still descend so an inner many/sequence
+      // under a node() is analyzed (it benefits even when its optional wrapper
+      // doesn't).
+      case "label":
+      case "trivia":
+      case "attempt":
+      case "withCtx":
+      case "expect":
         visit(def.parser, consumed);
         return;
       case "sequence":
         mark(def, consumed);
-        for (const p of def.parsers) visit(p, consumed);
-        return;
       case "choice":
         for (const p of def.parsers) visit(p, consumed);
         return;
@@ -2277,22 +2282,24 @@ function markUnusedValues(root) {
         if (def.otherwise) visit(def.otherwise, consumed);
         return;
       case "node":
+      // builds from captured children, NOT the inner parser value.
+      case "not":
+      case "peek":
+      // lookahead — value never observed
+      case "token":
         visit(def.parser, false);
         return;
       case "transform":
-        visit(def.parser, true);
-        return;
+      // the map fn reads the value → always consumed.
       case "field":
+      // the field capture records the parsed value → always consumed.
+      case "leaf":
         visit(def.parser, true);
         return;
       case "sepBy":
         visit(def.parser, true);
         visit(def.separator, false);
         return;
-      case "not":
-      case "peek":
-        visit(def.parser, false);
-        return;
       case "grammar":
         visit(def.parser, consumed);
         if (def.triviaParser) visit(def.triviaParser, false);
@@ -2301,19 +2308,6 @@ function markUnusedValues(root) {
         visit(def.parser, consumed);
         visit(def.sentinel, false);
         return;
-      case "token":
-        visit(def.parser, false);
-        return;
-      case "label":
-      case "trivia":
-      case "attempt":
-      case "withCtx":
-      case "expect":
-        visit(def.parser, consumed);
-        return;
-      case "leaf":
-        visit(def.parser, true);
-        return;
       case "lazy":
         return;
       default:
@@ -2616,6 +2610,7 @@ function matchesAt(sentinel, input, pos, ctx) {
 function captureError(ctx, error) {
   if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
 }
+var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
 
 // src/combinators/expect.ts
 function deriveExpected(c) {
@@ -2676,6 +2671,7 @@ function derive(c, seen) {
     case "optional":
     case "many":
     case "oneOrMore":
+    case "sepBy":
     case "transform":
     case "not":
     case "peek":
@@ -2823,7 +2819,7 @@ function choice(...args) {
           const result = parsers[idx].parse(input, pos, ctx);
           if (result.ok) return result;
           expected.push(...result.expected);
-          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
         if (ctx._probe !== void 0 || ctx._tolerant) for (const p of parsers) p.parse(input, pos, ctx);
@@ -4067,6 +4063,9 @@ function regex(pattern, flags = "") {
   };
 }
 
+// src/version.ts
+var PARSEMAN_VERSION = "0.61.1";
+
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
   const raw = constants[spec[0]];
@@ -4535,7 +4534,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
     if (!Number.isInteger(spec[2]) || spec[2] < 0) {
       throw new TypeError("table balanced lexical program has an invalid scan reference");
     }
-    const run = (_input, _pos, ctx, scan) => {
+    const run2 = (_input, _pos, ctx, scan) => {
       if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
       const result = scan.parse(_input, _pos, ctx);
       if (!result.ok) {
@@ -4545,7 +4544,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
       }
       return result.span.end;
     };
-    return Object.assign(run, { scan: spec[2] });
+    return Object.assign(run2, { scan: spec[2] });
   }
   if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
   if (spec[0] === 1) {
@@ -4682,11 +4681,12 @@ function assemblyExtraIps(prog) {
 }
 function expandCompact(p) {
   if ("code" in p) return p;
+  if (p.es === void 0) throw new Error(`parseman: this parser was printed by an earlier parseman; reprint it with parseman ${PARSEMAN_VERSION}`);
   return ownTableProgram({
     code: p.c,
     k: p.k,
     cc: p.x,
-    fx: p.e,
+    fx: p.e.map((set) => set.map((i) => p.es[i])),
     disp: p.d,
     rules: p.r,
     fns: p.f,
@@ -6591,6 +6591,206 @@ function asciiFoldKey(key) {
   }
   return out;
 }
+function matchesDispatchMatcher(value, matcher) {
+  const candidate = matcher.caseInsensitive ? asciiFoldKey(value) : value;
+  const expected = matcher.caseInsensitive ? asciiFoldKey(matcher.value) : matcher.value;
+  switch (matcher.kind) {
+    case "startsWith":
+      return candidate.startsWith(expected);
+    case "endsWith":
+      return candidate.endsWith(expected);
+    case "matches": {
+      const flags = matcher.caseInsensitive && !matcher.flags?.includes("i") ? `${matcher.flags ?? ""}i` : matcher.flags ?? "";
+      return new RegExp(matcher.value, flags).test(value);
+    }
+  }
+}
+function isStringMatcher(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const kind = value.kind;
+  return kind === "startsWith" || kind === "endsWith" || kind === "matches";
+}
+function fixedMatcher(kind, value) {
+  if (typeof value !== "string") throw new TypeError(`parseman: ${kind}() value must be a string`);
+  if (value.length === 0) throw new RangeError(`parseman: ${kind}() requires a non-empty value`);
+  return { kind, value };
+}
+function startsWith(prefix) {
+  return fixedMatcher("startsWith", prefix);
+}
+function endsWith(suffix) {
+  return fixedMatcher("endsWith", suffix);
+}
+function matches(pattern) {
+  if (!(pattern instanceof RegExp)) throw new TypeError("parseman: matches() requires a RegExp");
+  if (pattern.flags.includes("g") || pattern.flags.includes("y")) {
+    throw new TypeError("parseman: matches() does not accept global or sticky regex flags");
+  }
+  return { kind: "matches", value: pattern.source, flags: pattern.flags };
+}
+function dispatchMatcher(entry) {
+  switch (entry.kind) {
+    case "startsWith":
+      return startsWith(entry.value);
+    case "endsWith":
+      return endsWith(entry.value);
+    case "matches":
+      return matches(new RegExp(entry.value, entry.flags));
+  }
+}
+function when(key, parser2, opts = {}) {
+  const usesRouted = parserUsesRouted(parser2);
+  if (isStringMatcher(key)) {
+    return { kind: "whenMatcher", matcher: key, parser: parser2, caseInsensitive: opts.caseInsensitive ?? false, usesRouted };
+  }
+  const keys = Array.isArray(key) ? [...key] : [key];
+  if (keys.length === 0) throw new RangeError("parseman: when() requires at least one key");
+  for (const item of keys) {
+    if (typeof item !== "string") throw new TypeError("parseman: when() keys must be strings");
+  }
+  return { kind: "when", keys, parser: parser2, caseInsensitive: opts.caseInsensitive ?? false, usesRouted };
+}
+function otherwise(parser2, opts = {}) {
+  const usesRouted = parserUsesRouted(parser2);
+  return opts.commit === false ? { kind: "otherwise", parser: parser2, usesRouted, commit: false } : { kind: "otherwise", parser: parser2, usesRouted };
+}
+function routed(fallback) {
+  return {
+    _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 || 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)) {
+        pushCstLeaf(ctx, new PlainLeaf6(item.value, item.span));
+      }
+      return { ok: true, value: item.value, span: item.span };
+    }
+  };
+}
+function dispatch(selector, ...arms) {
+  if (parserUsesRouted(selector)) {
+    throw new Error("parseman: routed() can only appear inside a dispatch() branch");
+  }
+  let fallback;
+  let fallbackUsesRouted = false;
+  let fallbackCommits = true;
+  const matchers = [];
+  const cases = [];
+  const seen = [];
+  for (let i = 0; i < arms.length; i++) {
+    const arm = arms[i];
+    if (arm.kind === "otherwise") {
+      if (fallback !== void 0) throw new Error("parseman: dispatch() accepts at most one otherwise() arm");
+      if (i !== arms.length - 1) throw new Error("parseman: otherwise() must be the last dispatch() arm");
+      fallback = arm.parser;
+      fallbackUsesRouted = arm.usesRouted === true;
+      fallbackCommits = arm.commit !== false;
+      continue;
+    }
+    if (arm.kind === "whenMatcher") {
+      const matcher = arm.matcher;
+      matchers.push({
+        kind: matcher.kind,
+        value: matcher.value,
+        ...matcher.kind === "matches" ? { flags: matcher.flags } : {},
+        parser: arm.parser,
+        caseInsensitive: arm.caseInsensitive,
+        ...arm.usesRouted === true ? { usesRouted: true } : {}
+      });
+      continue;
+    }
+    for (const key of arm.keys) {
+      const folded = asciiFoldKey(key);
+      for (const prior of seen) {
+        const overlaps = arm.caseInsensitive || prior.caseInsensitive ? folded === prior.folded : key === prior.raw;
+        if (overlaps) throw new Error(`parseman: duplicate dispatch key ${JSON.stringify(key)}`);
+      }
+      seen.push({ raw: key, folded, caseInsensitive: arm.caseInsensitive });
+    }
+    cases.push({
+      keys: arm.keys,
+      parser: arm.parser,
+      caseInsensitive: arm.caseInsensitive,
+      ...arm.usesRouted === true ? { usesRouted: true } : {}
+    });
+  }
+  const meta = {
+    firstSet: selector._meta.firstSet,
+    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || matchers.some((entry) => entry.parser._meta.canMatchNewline) || (fallback?._meta.canMatchNewline ?? false),
+    isTrivia: false
+  };
+  const byKey = /* @__PURE__ */ new Map();
+  const byFoldedKey = /* @__PURE__ */ new Map();
+  for (const entry of cases) {
+    for (const key of entry.keys) {
+      if (entry.caseInsensitive) byFoldedKey.set(asciiFoldKey(key), entry);
+      else byKey.set(key, entry);
+    }
+  }
+  return {
+    _tag: "dispatch",
+    _meta: meta,
+    _def: {
+      tag: "dispatch",
+      selector,
+      cases,
+      ...matchers.length === 0 ? {} : { matchers },
+      ...fallback === void 0 ? {} : {
+        otherwise: fallback,
+        ...fallbackUsesRouted ? { otherwiseUsesRouted: true } : {},
+        ...fallbackCommits ? {} : { otherwiseCommit: false }
+      }
+    },
+    parse(input, pos, ctx) {
+      if (parserUsesRouted(selector)) {
+        throw new Error("parseman: routed() can only appear inside a dispatch() branch");
+      }
+      const selectorMark = saveTriviaMark(ctx);
+      const selected = selector.parse(input, pos, ctx);
+      if (!selected.ok) return selected;
+      const chosen = byKey.get(selected.value) ?? (byFoldedKey.size === 0 ? void 0 : byFoldedKey.get(asciiFoldKey(selected.value))) ?? matchers.find((matcher) => matchesDispatchMatcher(selected.value, matcher));
+      const branch = chosen ?? (fallback === void 0 ? void 0 : { keys: [], parser: fallback, caseInsensitive: false, usesRouted: fallbackUsesRouted });
+      if (branch === void 0) {
+        const expected = cases.flatMap((entry) => entry.keys.map((key) => JSON.stringify(key)));
+        return { ok: false, expected, span: { start: selected.span.end, end: selected.span.end } };
+      }
+      const savedRouted = ctx._routed;
+      const usesRouted = branchUsesRouted(branch);
+      let mark = saveTriviaMark(ctx);
+      if (usesRouted) {
+        rollbackTrivia(ctx, selectorMark);
+        mark = saveTriviaMark(ctx);
+        ctx._routed = { value: selected.value, span: selected.span };
+      }
+      let result;
+      try {
+        result = branch.parser.parse(input, usesRouted ? pos : selected.span.end, ctx);
+      } finally {
+        if (usesRouted) ctx._routed = savedRouted;
+      }
+      if (!result.ok) {
+        rollbackTrivia(ctx, mark);
+        return chosen === void 0 && !fallbackCommits ? result : { ...result, committed: true };
+      }
+      return {
+        ok: true,
+        value: [selected.value, result.value],
+        span: { start: pos, end: result.span.end }
+      };
+    }
+  };
+}
 
 // src/table/ops.ts
 var OP_LIT = 1;
@@ -6693,6 +6893,12 @@ var OP_NAMES = {
   [OP_STRICT]: "STRICT"
 };
 
+// src/combinators/link-scope.ts
+var scope;
+function afterLink(settle) {
+  scope?.push(settle);
+}
+
 // src/combinators/node.ts
 import { PlainNode, PlainSpan as PlainSpan7 } from "../cst/plain.js";
 function unwrapChild(child) {
@@ -6756,8 +6962,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   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 || (build ? buildReadsTrivia(def) : project === void 0);
   const readsState = build ? buildReadsState(def) : project === void 0;
-  const hasOwnFields = parserHasOwnFields(combinator);
-  const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+  let hasOwnFields = parserHasOwnFields(combinator);
+  let capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+  if (!hasOwnFields) {
+    afterLink(() => {
+      hasOwnFields = parserHasOwnFields(combinator);
+      capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
+    });
+  }
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
   let failExpected;
   return {
@@ -6863,7 +7075,7 @@ function selectOptionalSuffixLexBody(ir) {
 function reinstallsRuleTrivia(reference, target) {
   return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
 }
-function directTokenBodyParser(parser2, resolve, scope) {
+function directTokenBodyParser(parser2, resolve, scope2) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -6873,7 +7085,7 @@ function directTokenBodyParser(parser2, resolve, scope) {
     const wrapper = body._def;
     if (wrapper.tag === "grammar") {
       if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
-      if (scope !== void 0) scope.cleared = true;
+      if (scope2 !== void 0) scope2.cleared = true;
       body = wrapper.parser;
       continue;
     }
@@ -7130,10 +7342,10 @@ function directFixedLexNode(parser2, resolve, active, pureOnly = false, cleared
   }
 }
 function directFixedTokenBody(parser2, resolve) {
-  const scope = { cleared: false };
-  const body = directTokenBodyParser(parser2, resolve, scope);
+  const scope2 = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve, scope2);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope.cleared);
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set(), false, scope2.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve) {
@@ -8633,7 +8845,7 @@ var Encoder = class {
         const dispCovIds = this.plan?.dispatches.get(p);
         let dispCov = 0;
         const arms = [];
-        const routed = [];
+        const routed2 = [];
         const key = [], keyArm = [];
         const fold = [], foldArm = [];
         const match = [];
@@ -8641,7 +8853,7 @@ var Encoder = class {
         for (const c of d.cases) {
           const arm = arms.length;
           arms.push(this.covWrap(this.node(c.parser).ip, dispCovIds?.[dispCov++], 1));
-          routed.push(branchUsesRouted(c) ? 1 : 0);
+          routed2.push(branchUsesRouted(c) ? 1 : 0);
           for (const kk of c.keys) {
             expected.push(JSON.stringify(kk));
             if (c.caseInsensitive) {
@@ -8657,7 +8869,7 @@ var Encoder = class {
         for (const m of d.matchers ?? []) {
           const arm = arms.length;
           arms.push(this.covWrap(this.node(m.parser).ip, dispCovIds?.[dispCov++], 1));
-          routed.push(branchUsesRouted(m) ? 1 : 0);
+          routed2.push(branchUsesRouted(m) ? 1 : 0);
           if (!m.caseInsensitive) {
             match.push([KIND[m.kind], m.value, m.flags ?? "", arm]);
             continue;
@@ -8671,7 +8883,7 @@ var Encoder = class {
         }
         const other = d.otherwise === void 0 ? -1 : this.covWrap(this.node(d.otherwise).ip, dispCovIds?.[dispCov++], 1);
         const dspIdx = this.dsp.length;
-        this.dsp.push({ key, keyArm, fold, foldArm, match, routed, expected });
+        this.dsp.push({ key, keyArm, fold, foldArm, match, routed: routed2, expected });
         const head = this.emitHead(OP_DISPATCH, 5 + arms.length);
         this.code[head + 1] = sel;
         this.code[head + 2] = dspIdx;
@@ -9987,6 +10199,12 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
 
 // src/table/child-slots.ts
 function childSlots(code, ip, out) {
+  const from = out.length;
+  if (!childSlotOffsets(code, ip, out)) return false;
+  for (let i = from; i < out.length; i++) out[i] = code[out[i]];
+  return true;
+}
+function childSlotOffsets(code, ip, out) {
   switch (code[ip]) {
     // ZERO-WIDTH / TERMINAL ROWS — no successor. `OP_GUARD` and `OP_ADJ` are both
     // childless tests. `OP_LIVE` holds a hand-written combinator in `prog.fns`; its
@@ -10019,7 +10237,7 @@ function childSlots(code, ip, out) {
     case OP_COV:
     case OP_REJECT:
     case OP_GAPGATE:
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       return true;
     // Single child at `ip + 2`.
     case OP_GATE:
@@ -10036,55 +10254,55 @@ function childSlots(code, ip, out) {
     case OP_ARMGATE:
     case OP_RGATE:
     case OP_RGATE2:
-      out.push(code[ip + 2]);
+      out.push(ip + 2);
       return true;
     // `STRICT strict tolerant` — both encodings are reachable; an assembly keeps one.
     case OP_STRICT:
-      out.push(code[ip + 1], code[ip + 2]);
+      out.push(ip + 1, ip + 2);
       return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
     // data the enclosing `dispatch()` already consumed, so the only edge is the
     // fallback.
     case OP_ROUTED:
-      if (code[ip + 1] >= 0) out.push(code[ip + 1]);
+      if (code[ip + 1] >= 0) out.push(ip + 1);
       return true;
     // `DISPATCH sel d other otherRouted n a1 … an` — the SELECTOR is a child on
     // exactly the same footing as the arms: it runs inside whatever node and scope
     // this site sits in.
     case OP_DISPATCH: {
-      out.push(code[ip + 1]);
-      if (code[ip + 3] >= 0) out.push(code[ip + 3]);
+      out.push(ip + 1);
+      if (code[ip + 3] >= 0) out.push(ip + 3);
       const n = code[ip + 5];
-      for (let i = 0; i < n; i++) out.push(code[ip + 6 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 6 + i);
       return true;
     }
     case OP_SEQ:
     case OP_SEQV: {
       const n = code[ip + 1];
-      for (let i = 0; i < n; i++) out.push(code[ip + 2 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 2 + i);
       return true;
     }
     case OP_SEQX: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 3 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 3 + i);
       return true;
     }
     case OP_CHOICE: {
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + i);
       return true;
     }
     // Arms are stride-2 from `ip + 4` — the gate word sits beside each arm offset.
     case OP_GREEDY: {
-      out.push(code[ip + 1]);
+      out.push(ip + 1);
       const n = code[ip + 2];
-      for (let i = 0; i < n; i++) out.push(code[ip + 4 + 2 * i]);
+      for (let i = 0; i < n; i++) out.push(ip + 4 + 2 * i);
       return true;
     }
     case OP_REP:
     case OP_REPV:
-      out.push(code[ip + 1]);
-      if (code[ip + 4] >= 0) out.push(code[ip + 4]);
+      out.push(ip + 1);
+      if (code[ip + 4] >= 0) out.push(ip + 4);
       return true;
     default:
       return false;
@@ -10899,7 +11117,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, s
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const LOGS = (prog.triviaSpecs?.length ?? 0) > 0 || cfg.inheritedTrivia === true;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
   const reachable = [...reachableSites(code, roots)];
@@ -10972,7 +11190,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, s
     const op = code[ip];
     sinkBits.set(
       ip,
-      op === OP_SCAN || !scanSinkNeutral && op === OP_LEX_PROGRAM && t2.lexPrograms[code[ip + 1]].scan !== void 0 ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC && (op === OP_REP || op === OP_REPV) ? 2 : 0)
+      op === OP_SCAN || !scanSinkNeutral && op === OP_LEX_PROGRAM && t2.lexPrograms[code[ip + 1]].scan !== void 0 ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC2 && (op === OP_REP || op === OP_REPV) ? 2 : 0)
     );
   }
   const sinkKids = [];
@@ -11497,7 +11715,7 @@ if(v!==FAIL)return v
 const err={_tag:'parseError',span:${prog.lines === 1 ? "spanLines(ctx,pos,pos)" : "new _SP(pos,pos)"},expected:${xf}}
 const es=ctx._errors
 if(es!==undefined)es.push(err)
-${REC ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
+${REC2 ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
 EC.e=pos
 return err
 }`;
@@ -11627,7 +11845,7 @@ return v
       }
       case OP_LEX_PROGRAM: {
         const programId = code[ip + 1];
-        const run = hoist("lexProgram", `LEXPROG[${programId}]`);
+        const run2 = hoist("lexProgram", `LEXPROG[${programId}]`);
         const scanId = t2.lexPrograms[programId].scan;
         if (scanId !== void 0) return `${head}
 const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan
@@ -11645,7 +11863,7 @@ ctx._cstTriviaLog=undefined
 ctx._triviaLog=undefined
 ctx._rootTriviaLog=undefined
 let e
-try{e=${run}(input,pos,ctx,SCANS[${scanId}])}finally{
+try{e=${run2}(input,pos,ctx,SCANS[${scanId}])}finally{
 _pfScan=sScan
 ctx.trivia=sTri
 ctx.triviaKindLabels=sKinds
@@ -11664,7 +11882,7 @@ EC.e=e
 return v
 }`;
         return `${head}
-const e=${run}(input,pos,ctx)
+const e=${run2}(input,pos,ctx)
 if(e<0)return FAIL
 const v=input.slice(pos,e)
 if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,new _LF(v,new _SP(pos,e)))
@@ -11675,7 +11893,7 @@ return v
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
@@ -11741,7 +11959,7 @@ return null
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const logs = clean && LOGS && failureLogRollback(prog, ip);
         const p = tmp();
         return `${head}
@@ -11772,15 +11990,15 @@ return v
           const childIp = code[base + i];
           kids.push(code[childIp] === OP_ADJ ? "" : link(childIp));
         }
-        const sy = REC ? `${tmp()}sy` : "";
+        const sy = REC2 ? `${tmp()}sy` : "";
         const pub = (i) => {
           const s = sentRef(code[base + n + i]);
           return s === "undefined" ? `ctx._sync=${sy}` : `ctx._sync=${s}??${sy}`;
         };
         const parts = [head];
-        if (REC) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
+        if (REC2) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
         parts.push(`const v0=${kids[0]}(input,pos,ctx)`, "if(v0===FAIL)return FAIL");
-        const close = () => REC ? `${parts.join("\n")}
+        const close = () => REC2 ? `${parts.join("\n")}
 }finally{ctx._sync=${sy}}
 }` : `${parts.join("\n")}
 }`;
@@ -11793,7 +12011,7 @@ return v
         for (let i = 1; i < n; i++) {
           const vn = `v${i}`;
           parts.push(`let ${vn}`);
-          if (REC) parts.push(pub(i));
+          if (REC2) parts.push(pub(i));
           const childIp = code[base + i];
           if (code[childIp] === OP_ADJ) {
             const negated = code[childIp + 1] === 1;
@@ -11898,7 +12116,7 @@ return FAIL
           if (maskable) maskPlan.push(~di);
           const p = tmp();
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
-          const rollbackMask = REC ? -1 : encodedRollbackMask;
+          const rollbackMask = REC2 ? -1 : encodedRollbackMask;
           const hasRollback = rollbackMask !== 0;
           const logMask = rollbackMask === -1 || !LOGS ? 0 : choiceLogRollbackMask(prog, ip);
           const choiceMark = hasRollback ? emitMark(p, L.buf, L.raw, sinks) : "";
@@ -12151,7 +12369,7 @@ return [key,v]
         const collect = op === OP_REP;
         let itemCls;
         let itemAscii = false;
-        if (!REC) {
+        if (!REC2) {
           const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
           if (itemClassIndex >= 0) {
             const resolved = t2.cc[itemClassIndex];
@@ -12164,14 +12382,14 @@ return [key,v]
         const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
         let sepCls;
         let sepAscii = false;
-        if (!REC && sepIp >= 0 && (code[ip + 5] & 8) !== 0 && !leadingTriviaFieldAt(code, k, sepIp) && !rowNullable(code, k, sepIp, nullable2)) {
+        if (!REC2 && sepIp >= 0 && (code[ip + 5] & 8) !== 0 && !leadingTriviaFieldAt(code, k, sepIp) && !rowNullable(code, k, sepIp, nullable2)) {
           const resolved = t2.cc[code[ip + 8]];
           const ci = classes.push([resolved]) - 1;
           classPlan.push([code[ip + 8]]);
           sepCls = hoist("rs", `CLS[${ci}][0]`);
           sepAscii = isAsciiOnlyClass(resolved);
         }
-        const gapIp = !gapNeutral && sepIp < 0 && min === 0 && !REC && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
+        const gapIp = !gapNeutral && sepIp < 0 && min === 0 && !REC2 && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
         let gapCode = (_rb) => "";
         if (gapIp >= 0) {
           const row = code[gapIp + 2];
@@ -12256,11 +12474,11 @@ ${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
 }`;
         const my = `${p}my`;
-        const recFx = !REC ? "" : (flags & 16) !== 0 ? "[]" : fxRef(code[ip + 6]);
-        const sepSent = REC ? sentRef(code[ip + 7]) : "undefined";
+        const recFx = !REC2 ? "" : (flags & 16) !== 0 ? "[]" : fxRef(code[ip + 6]);
+        const sepSent = REC2 ? sentRef(code[ip + 7]) : "undefined";
         const recSent = sep === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
         const recGate = sep !== void 0 || min === 0 ? "" : `count>=${min}&&`;
-        const recBranch = !REC ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
+        const recBranch = !REC2 ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
 ${sep === void 0 ? `${rb}
 ` : ""}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
 ${collect ? "out.push(rr.error)\n" : ""}captureError(ctx,rr.error)
@@ -12271,7 +12489,7 @@ continue
 `;
         return `${head}
 const out=${collect ? "[]" : "undefined"}
-${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
+${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC2 ? `const ${my}=ctx._sync
 ` : ""}${itemCls === void 0 && sepCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
 `}let cur=pos
 let count=0
@@ -12314,7 +12532,7 @@ ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 `}${gapCode(rb)}ctx._fc=false
 const v=${child}(input,itemStart,ctx)
 ${gapIp >= 0 ? "if(gapped)GAP.at=-1\n" : ""}if(v===FAIL){
-${REC ? `if(ctx._fc===true){
+${REC2 ? `if(ctx._fc===true){
 ${rb}
 return FAIL
 }
@@ -12540,13 +12758,13 @@ return nd
     }
   }
   const served = (ip) => select === void 0 || select.has(resolveAlias(ip));
-  const ruleEntries = [];
+  const ruleEntries2 = [];
   for (const [rname, entryIp] of Object.entries(prog.rules)) {
     if (!served(entryIp)) continue;
     const target = link(entryIp);
     const rn = `_r_${rname.replace(/[^A-Za-z0-9_$]/g, "_")}`;
     bodies.push(`const ${rn}=${target}`);
-    ruleEntries.push(`${q(rname)}:${rn}`);
+    ruleEntries2.push(`${q(rname)}:${rn}`);
   }
   const extra = [];
   const exported = /* @__PURE__ */ new Set();
@@ -12612,7 +12830,7 @@ _pfHost=prior[1]
 EC.e=prior[2]
 }
 return{
-pieces:{${ruleEntries.join(",")}},
+pieces:{${ruleEntries2.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
@@ -12721,31 +12939,31 @@ function lines(prefix, body, options = {}) {
     _def: { tag: "lines", prefix, body, ...first === void 0 ? {} : { first }, ...lazy === void 0 ? {} : { lazy } },
     parse(input, pos, ctx) {
       const c = ctx;
-      const probe = createDetachedParseContext(false, ctx.state);
-      probe.lineView = c.lineView;
-      const run = [];
+      const probe2 = createDetachedParseContext(false, ctx.state);
+      probe2.lineView = c.lineView;
+      const run2 = [];
       const parts = [];
       let offset = 0;
       for (let start = pos; start < input.length || start === pos; ) {
         let end2 = input.indexOf("\n", start);
         if (end2 < 0) end2 = input.length;
-        probe._columnsSplit = void 0;
-        const head = (run.length === 0 ? opening : prefix).parse(input, start, probe);
+        probe2._columnsSplit = void 0;
+        const head = (run2.length === 0 ? opening : prefix).parse(input, start, probe2);
         let content;
         let joined;
         if (head.ok && head.span.end <= end2) {
           content = head.span.end;
           joined = "prefix";
-        } else if (run.length === 0) {
+        } else if (run2.length === 0) {
           return { ok: false, expected: head.ok ? ["line prefix"] : head.expected, span: { start, end: start } };
-        } else if (lazy !== void 0 && lazy.parse(input, start, probe).ok) {
+        } else if (lazy !== void 0 && lazy.parse(input, start, probe2).ok) {
           content = start;
           joined = "lazy";
         } else break;
-        const mark = probe._columnsSplit;
+        const mark = probe2._columnsSplit;
         const here = columnAt(input, content, c);
         const split = joined === "prefix" && mark !== void 0 && mark.at === content ? mark.split : here.split;
-        run.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
+        run2.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
         const text = input.slice(content, end2);
         const newline = end2 < input.length;
         parts.push(newline ? `${text}
@@ -12754,11 +12972,11 @@ function lines(prefix, body, options = {}) {
         start = end2 + 1;
         if (!newline) break;
       }
-      const view = { lines: run, parent: c.lineView };
+      const view = { lines: run2, parent: c.lineView };
       const saved = c.lineView, starts = c._lineStarts, lineIndex = c._lineIndex, scanned = c._lineScannedTo, probing = c._probe;
       const errors = c._errors?.length ?? 0;
       let cursor = -1;
-      if (probing !== void 0) for (const line2 of run) {
+      if (probing !== void 0) for (const line2 of run2) {
         if (probing.offset >= line2.source && probing.offset <= line2.end) {
           cursor = line2.offset + probing.offset - line2.source;
           break;
@@ -12791,8 +13009,8 @@ function lines(prefix, body, options = {}) {
       }
       const stop = result.span.end;
       const index = lineIndexAt(view, stop);
-      const line = run[index];
-      const end = stop === line.offset && index > 0 ? run[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      const line = run2[index];
+      const end = stop === line.offset && index > 0 ? run2[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
       recordLineRangeFromContext(c, input, pos, end);
       return { ok: true, value: result.value, span: { start: pos, end } };
     }
@@ -12901,12 +13119,12 @@ function literal(value, opts = {}) {
 }
 
 // src/combinators/ref.ts
-function withRuleTrivia(trivia2, ctx, run) {
+function withRuleTrivia(trivia2, ctx, run2) {
   const savedLabels = ctx.triviaKindLabels;
   ctx.trivia = trivia2;
   ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
   try {
-    return run();
+    return run2();
   } finally {
     ctx.trivia = void 0;
     ctx.triviaKindLabels = savedLabels;
@@ -13285,9 +13503,6 @@ function clearOf(ranges, input, from, to) {
   return true;
 }
 
-// src/version.ts
-var PARSEMAN_VERSION = "0.60.6";
-
 // src/table/assemble.ts
 import { PlainBuf as PlainBuf2, PlainField, PlainLeaf as PlainLeaf9, PlainNode as PlainNode2, PlainSpan as PlainSpan10 } from "../cst/plain.js";
 
@@ -13411,6 +13626,19 @@ function failCleanAnalysis(code) {
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
 var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
+function assertHostModeCompatible(mode, build, hostBranchElided = true) {
+  const isCstHost = build?._parsemanCstOutput === true;
+  if (mode === "ast" && isCstHost && hostBranchElided) {
+    throw new Error(
+      "parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes build through their own `build` callbacks and no positioned-CST branch was emitted. It cannot be driven with a positioned-CST host (cstBuildHost / a language-service host). Compile a second artifact from the SAME grammar with `compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second `rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead."
+    );
+  }
+  if (mode === "cst" && !isCstHost) {
+    throw new Error(
+      'parseman: this parser was compiled for host mode "cst", so every node builds through a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use an artifact compiled with the default `hostMode: "ast"` to get the grammar\'s own AST.'
+    );
+  }
+}
 
 // src/grammar-metadata.ts
 var GRAMMAR_COVERAGE_DEFINITIONS = /* @__PURE__ */ Symbol.for("parseman.grammarCoverageDefinitions");
@@ -13545,8 +13773,8 @@ function linkMatcher(m) {
 }
 var NO_COVERAGE = (_id) => {
 };
-function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren = true, inheritedTrivia = false) {
-  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe ? 16 : 0) | (hostReadsChildren ? 0 : 32) | (inheritedTrivia ? 64 : 0);
+function cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe2, hostReadsChildren = true, inheritedTrivia = false) {
+  return (hostCst ? 1 : 0) | (trackLines ? 2 : 0) | (tolerant ? 4 : 0) | (coverage ? 8 : 0) | (probe2 ? 16 : 0) | (hostReadsChildren ? 0 : 32) | (inheritedTrivia ? 64 : 0);
 }
 function cfgKey(c) {
   return cfgKeyOf(c.hostCst, c.trackLines, c.tolerant, c.coverage, c.probe, c.hostReadsChildren, c.inheritedTrivia);
@@ -13563,7 +13791,7 @@ function assemble(t2, prog, cfg) {
   const triviaScan = t2.triviaScan;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
   const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
@@ -13613,7 +13841,7 @@ function assemble(t2, prog, cfg) {
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   const NULLABLE = /* @__PURE__ */ new Map();
-  const CLEAN = REC ? () => false : failCleanAnalysis(code);
+  const CLEAN = REC2 ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = new PlainLeaf9(value, new PlainSpan10(s, e));
     pushCstLeaf(ctx, lf);
@@ -14324,7 +14552,7 @@ function assemble(t2, prog, cfg) {
   };
   function lookaheadLedNode(ip) {
     const op = code[ip];
-    if (op !== OP_NODE && op !== OP_NODE_TRACK || hostCst || REC || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
+    if (op !== OP_NODE && op !== OP_NODE_TRACK || hostCst || REC2 || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
     if (passCollapse(code, ip, hostCst) || gatedPassCollapse(code, ip, hostCst) !== void 0) return void 0;
     const body = code[ip + 2];
     const bop = code[body];
@@ -14700,7 +14928,7 @@ function assemble(t2, prog, cfg) {
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         const expectSpan = (ctx, pos) => prog.lines === 1 ? spanLines(ctx, pos, pos) : new PlainSpan10(pos, pos);
-        if (REC) {
+        if (REC2) {
           return (input, pos, ctx) => {
             const v = child(input, pos, ctx);
             if (v !== FAIL) return v;
@@ -15097,8 +15325,8 @@ function assemble(t2, prog, cfg) {
         };
       }
       case OP_LEX_PROGRAM: {
-        const run = t2.lexPrograms[code[ip + 1]];
-        const scanId = run.scan;
+        const run2 = t2.lexPrograms[code[ip + 1]];
+        const scanId = run2.scan;
         if (scanId !== void 0) {
           return (input, pos, ctx) => {
             const sTrivia = ctx.trivia, sKinds = ctx.triviaKindLabels;
@@ -15119,7 +15347,7 @@ function assemble(t2, prog, cfg) {
             ctx._rootTriviaLog = void 0;
             let end;
             try {
-              end = run(input, pos, ctx, scans[scanId]);
+              end = run2(input, pos, ctx, scans[scanId]);
             } finally {
               SCAN = sScan;
               ctx.trivia = sTrivia;
@@ -15140,7 +15368,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         return (input, pos, ctx) => {
-          const end = run(input, pos, ctx);
+          const end = run2(input, pos, ctx);
           if (end < 0) return FAIL;
           const value = input.slice(pos, end);
           if (cstCaptureActive(ctx)) pushCstLeaf(ctx, new PlainLeaf9(value, new PlainSpan10(pos, end)));
@@ -15241,7 +15469,7 @@ function assemble(t2, prog, cfg) {
             return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
           };
         };
-        if (REC) {
+        if (REC2) {
           const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
@@ -15730,7 +15958,7 @@ function assemble(t2, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
-          const predecide = !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines;
           const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
           const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
           const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
@@ -15960,7 +16188,7 @@ function assemble(t2, prog, cfg) {
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
           const pBit = [];
           const pRec = [];
-          if (!REC && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+          if (!REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
             for (let i = 0; i < n; i++) {
               for (const terminal of largeChoiceLiteralPretest(code, k, code[base + i]) ?? []) {
                 pBit.push(1 << i);
@@ -16248,18 +16476,18 @@ function assemble(t2, prog, cfg) {
         const itemFx = reportItem ? fx[code[ip + 6]] : EMPTY_FX2;
         const collect = op === OP_REP;
         const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
-        const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
+        const itemClass = !REC2 && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const sepClassIndex = sepIp >= 0 && !sepLeads && (flags & 8) !== 0 ? code[ip + 8] : -1;
-        const sepClass = !REC && sepClassIndex >= 0 && !rowNullable(code, k, sepIp, NULLABLE) ? cc[sepClassIndex] : void 0;
-        const gapIp = sepIp < 0 && min === 0 && !REC && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
+        const sepClass = !REC2 && sepClassIndex >= 0 && !rowNullable(code, k, sepIp, NULLABLE) ? cc[sepClassIndex] : void 0;
+        const gapIp = sepIp < 0 && min === 0 && !REC2 && code[code[ip + 1]] === OP_GAPGATE ? code[ip + 1] : -1;
         const gapRow = gapIp >= 0 ? code[gapIp + 2] : -1;
         const gapRe = gapIp >= 0 ? k[code[gapRow + 1]] : void 0;
         const gapFollow = gapIp >= 0 ? cc[code[gapIp + 3]] : void 0;
         const gapOther = gapIp >= 0 && code[gapIp + 4] >= 0 ? cc[code[gapIp + 4]] : void 0;
         const skipBeforeFirst = sepIp < 0 && min === 0;
         const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
-        if (REC) {
+        if (REC2) {
           const itemFx2 = fx[code[ip + 6]];
           const recFx = (flags & 16) !== 0 ? EMPTY_FX2 : itemFx2;
           const sepSent = sentinelFor(code[ip + 7]);
@@ -16469,10 +16697,10 @@ function assemble(t2, prog, cfg) {
         const hasFold = spec.byFold.size > 0;
         const match = spec.match;
         const matchN = match.length;
-        const routed = spec.routed;
+        const routed2 = spec.routed;
         const expected = spec.expected;
         const validArm = (arm) => Number.isInteger(arm) && arm >= 0 && arm < n;
-        if (routed.length !== n) throw new TypeError("table assembler: malformed dispatch routed arity");
+        if (routed2.length !== n) throw new TypeError("table assembler: malformed dispatch routed arity");
         for (const arm of byKey.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch exact arm");
         for (const arm of byFold.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch folded arm");
         for (const m of match) if (!validArm(m[3])) throw new TypeError("table assembler: malformed dispatch matcher arm");
@@ -16497,7 +16725,7 @@ function assemble(t2, prog, cfg) {
         const classify = hasFold ? matchBlock === void 0 ? (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) : (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) ?? matchBlock(key) : matchBlock === void 0 ? (key) => byKey.get(key) : (key) => byKey.get(key) ?? matchBlock(key);
         const neverBranch = () => FAIL;
         const bindArms = (start) => {
-          const branch = (i) => i < n ? dispatchBranch(link(code[armBase + i]), routed[i] === 1) : neverBranch;
+          const branch = (i) => i < n ? dispatchBranch(link(code[armBase + i]), routed2[i] === 1) : neverBranch;
           const next = start + 4 < n ? bindArms(start + 4) : void 0;
           return dispatchArmBlock(
             start,
@@ -16812,7 +17040,7 @@ function assemble(t2, prog, cfg) {
         lead,
         asciiFoldKey,
         ROUTED_FX,
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -16901,7 +17129,7 @@ function assemble(t2, prog, cfg) {
         // — a strict one emits no reader — and through the SAME `sentinelFor` memo
         // the closure pieces use, so both engines resync to the same combinator
         // object rather than to two separately constructed ones.
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -17116,9 +17344,9 @@ var AssemblyCache = class {
     const trackLines = ctx.trackLines === true;
     const tolerant = ctx._tolerant === true;
     const coverage = ctx._grammarCoverage !== void 0;
-    const probe = ctx._probe !== void 0;
+    const probe2 = ctx._probe !== void 0;
     const inheritedTrivia = this.noOwnTrivia && ctx.trivia !== void 0;
-    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe, hostReadsChildren, inheritedTrivia);
+    const key = cfgKeyOf(hostCst, trackLines, tolerant, coverage, probe2, hostReadsChildren, inheritedTrivia);
     let cache = this.byCfg;
     if (hostCaptureTrivia !== void 0) {
       if (this.hostPredicate === hostCaptureTrivia) {
@@ -17138,7 +17366,7 @@ var AssemblyCache = class {
       trackLines,
       tolerant,
       coverage,
-      probe,
+      probe: probe2,
       inheritedTrivia
     });
     cache[key] = made;
@@ -17271,12 +17499,15 @@ function assertPrintable(prog, who) {
   }
 }
 function programFields(prog, fns, opts = {}) {
+  const tokens = [...new Set(prog.fx.flat())];
+  const tokenAt = new Map(tokens.map((token2, i) => [token2, i]));
   return [
     ...emitAssemblies(prog, opts.assemblies ?? []),
     `c:[${prog.code.join(",")}],`,
     `k:[${prog.k.map(emitConst).join(",")}],`,
     `x:${emitClassPool(prog.cc)},`,
-    `e:[${prog.fx.map((f) => `[${f.map(jsString).join(",")}]`).join(",")}],`,
+    `e:[${prog.fx.map((f) => `[${f.map((token2) => tokenAt.get(token2)).join(",")}]`).join(",")}],`,
+    `es:[${tokens.map(jsString).join(",")}],`,
     `d:[${prog.disp.map((a) => `[${a.join(",")}]`).join(",")}],`,
     `r:${JSON.stringify(prog.rules)},`,
     ...prog.lines === 1 ? ["l:1,"] : [],
@@ -18047,36 +18278,36 @@ function findRegexFragments(visited) {
       if (branches.length >= 2) runs.add(branches.join("|"));
       for (let i = 0; i < branches.length; i++) {
         for (let n = 2; n <= Math.min(MAX_RUN, branches.length - i); n++) {
-          const run = branches.slice(i, i + n).join("|");
-          if (run.length < 4) continue;
-          runs.add(run);
+          const run2 = branches.slice(i, i + n).join("|");
+          if (run2.length < 4) continue;
+          runs.add(run2);
         }
       }
     }
-    for (const run of runs) {
-      let e = byRun.get(run);
+    for (const run2 of runs) {
+      let e = byRun.get(run2);
       if (e === void 0) {
-        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run.split("|").length };
-        byRun.set(run, e);
+        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run2.split("|").length };
+        byRun.set(run2, e);
       }
       if (e.nodes.has(v.p)) continue;
       e.nodes.add(v.p);
       e.occ.push({ site: v.site, source: d.source });
     }
   }
-  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run, e]) => ({ run, e, savings: (e.occ.length - 1) * run.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
+  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run2, e]) => ({ run: run2, e, savings: (e.occ.length - 1) * run2.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
   const kept = [];
   for (const c of candidates) {
     if (kept.some((k) => k.e.occ.length >= c.e.occ.length && `|${k.run}|`.includes(`|${c.run}|`))) continue;
     kept.push(c);
   }
-  return kept.map(({ run, e }) => ({
+  return kept.map(({ run: run2, e }) => ({
     kind: "regex-fragment",
-    id: `regex-fragment:${run}`,
-    fragment: run,
+    id: `regex-fragment:${run2}`,
+    fragment: run2,
     branches: e.branches,
     count: e.occ.length,
-    savings: (e.occ.length - 1) * run.length,
+    savings: (e.occ.length - 1) * run2.length,
     sources: e.occ.map((o) => `/${o.source}/`),
     sites: e.occ.map((o) => o.site),
     suggestion: `this ${e.branches}-branch alternation is re-spelled in ${e.occ.length} DISTINCT regex() terminals. Hoist it to one shared source string and interpolate it (\`new RegExp(\\\`\u2026\\\${OP}\u2026\\\`)\`) or lift the shared part into its own terminal \u2014 an edit to the operator set currently has to land in ${e.occ.length} places, and the analysis cannot tell you when one of them drifts.`
@@ -18930,9 +19161,9 @@ function withAmbient(ruleMap, opts) {
     const addTrivia = opts.trivia !== void 0 && rule2._meta.grammarTrivia === void 0;
     const addScanSkip = opts.scanSkip !== void 0 && rule2._meta.grammarScanSkip === void 0;
     if (!addTrivia && !addScanSkip) return [name, rule2];
-    let wrapped = wrappers.get(rule2);
-    if (wrapped === void 0) {
-      wrapped = {
+    let wrapped2 = wrappers.get(rule2);
+    if (wrapped2 === void 0) {
+      wrapped2 = {
         ...rule2,
         _meta: {
           ...rule2._meta,
@@ -18940,9 +19171,9 @@ function withAmbient(ruleMap, opts) {
           ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
         }
       };
-      wrappers.set(rule2, wrapped);
+      wrappers.set(rule2, wrapped2);
     }
-    return [name, wrapped];
+    return [name, wrapped2];
   });
 }
 function compileRuleMapRunnable(ruleMap, opts = {}) {
@@ -19124,7 +19355,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   const emitOpts = { fnSources: sources };
   const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
   const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  const runOnce2 = (input, pos, ctx) => entry(input, pos, ctx);
   return {
     source,
     inlineExpression,
@@ -19138,10 +19369,10 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
     // parser runs where a combinator does. A caller probing many positions
     // passes one context and pays for none per call.
     parse(input, pos = 0, ctx) {
-      return runOnce(input, pos, ctx ?? createParseContext());
+      return runOnce2(input, pos, ctx ?? createParseContext());
     },
     parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
+      return runOnce2(input, pos, parseCtx);
     },
     /**
      * NO LONGER REFUSES. It used to throw unless the caller passed
@@ -19157,7 +19388,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
       const errors = [];
       ctx._errors = errors;
       ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
+      const r = runOnce2(input, pos, ctx);
       return { ...r, errors };
     }
   };
@@ -19402,6 +19633,38 @@ function not(combinator) {
   };
 }
 
+// src/combinators/withCtx.ts
+function withCtx(extra, combinator) {
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  const parse2 = typeof extra === "function" ? (input, pos, ctx) => {
+    const saved = ctx.state;
+    ctx.state = extra(saved);
+    try {
+      return combinator.parse(input, pos, ctx);
+    } finally {
+      ctx.state = saved;
+    }
+  } : (input, pos, ctx) => {
+    const saved = ctx.state;
+    ctx.state = extra;
+    try {
+      return combinator.parse(input, pos, ctx);
+    } finally {
+      ctx.state = saved;
+    }
+  };
+  return {
+    _tag: "withCtx",
+    _meta: meta,
+    _def: { tag: "withCtx", extra, parser: combinator },
+    parse: parse2
+  };
+}
+
 // src/analysis/rebuild.ts
 var FROZEN_TAGS = /* @__PURE__ */ new Set([
   "dispatch",
@@ -19415,6 +19678,7 @@ var FROZEN_TAGS = /* @__PURE__ */ new Set([
   "lines",
   "columns"
 ]);
+var THAWED_TAGS = /* @__PURE__ */ new Set(["dispatch", "withCtx", "routed", "guard"]);
 var CARRIED_META = [
   "grammarTrivia",
   "grammarScanSkip",
@@ -19453,7 +19717,9 @@ function subtreeContains(p, targets) {
   walk(p);
   return hit;
 }
-function rebuildCombinator(root, replacements) {
+function rebuildCombinator(root, replacements, options = {}) {
+  const thaw = options.thaw === true;
+  const after = options.after ?? ((_p, out) => out);
   const memo = /* @__PURE__ */ new Map();
   const frozenKeys = /* @__PURE__ */ new Set();
   const frozen = [];
@@ -19473,15 +19739,16 @@ function rebuildCombinator(root, replacements) {
       return p;
     }
     const here = p._ruleName ?? rule2;
-    if (FROZEN_TAGS.has(d.tag)) {
+    if (FROZEN_TAGS.has(d.tag) && !(thaw && THAWED_TAGS.has(d.tag))) {
       const key = JSON.stringify([here, d.tag]);
       if (!frozenKeys.has(key)) {
         frozenKeys.add(key);
         frozen.push({ tag: d.tag, rule: here });
       }
       for (const t2 of subtreeContains(p, targets)) if (!unapplied.includes(t2)) unapplied.push(t2);
-      memo.set(p, p);
-      return p;
+      const kept = after(p, p);
+      memo.set(p, kept);
+      return kept;
     }
     if (d.tag === "lazy") {
       let target;
@@ -19518,6 +19785,14 @@ function rebuildCombinator(root, replacements) {
         break;
       }
       case "choice": {
+        if (d.gates.some((g) => g !== null) && thaw) {
+          const unsafeChoice = choice;
+          out = unsafeChoice(...d.parsers.map((arm, i) => {
+            const gate = d.gates[i];
+            return gate ? { combinator: one(arm), gate } : one(arm);
+          }));
+          break;
+        }
         if (d.gates.some((g) => g !== null)) {
           const key = JSON.stringify([here, "choice(gated)"]);
           if (!frozenKeys.has(key)) {
@@ -19525,8 +19800,9 @@ function rebuildCombinator(root, replacements) {
             frozen.push({ tag: "choice(gated)", rule: here });
           }
           for (const t2 of subtreeContains(p, targets)) if (!unapplied.includes(t2)) unapplied.push(t2);
-          memo.set(p, p);
-          return p;
+          const kept = after(p, p);
+          memo.set(p, kept);
+          return kept;
         }
         const kids = d.parsers.map(one);
         out = choice(...kids);
@@ -19604,13 +19880,33 @@ function rebuildCombinator(root, replacements) {
             frozen.push({ tag: "node(untyped+build+opts)", rule: here });
           }
           for (const t2 of subtreeContains(p, targets)) if (!unapplied.includes(t2)) unapplied.push(t2);
-          memo.set(p, p);
-          return p;
+          const kept = after(p, p);
+          memo.set(p, kept);
+          return kept;
         }
         out = d.type === void 0 ? d.build === void 0 ? node(one(d.parser), opts) : node(one(d.parser), d.build) : node(d.type, one(d.parser), d.build, opts);
         if (d.buildRawUnused === true && out._def.tag === "node") out._def.buildRawUnused = true;
         break;
       }
+      case "dispatch": {
+        const arms = d.cases.map((e) => when(e.keys, one(e.parser), e.caseInsensitive ? { caseInsensitive: true } : void 0));
+        for (const e of d.matchers ?? []) {
+          arms.push(when(dispatchMatcher(e), one(e.parser), e.caseInsensitive ? { caseInsensitive: true } : void 0));
+        }
+        if (d.otherwise) arms.push(otherwise(one(d.otherwise), d.otherwiseCommit === false ? { commit: false } : void 0));
+        const unsafeDispatch = dispatch;
+        out = unsafeDispatch(one(d.selector), ...arms);
+        break;
+      }
+      case "withCtx":
+        out = withCtx(d.extra, one(d.parser));
+        break;
+      case "routed":
+        out = d.fallback === void 0 ? routed() : routed(one(d.fallback));
+        break;
+      case "guard":
+        out = p;
+        break;
       case "grammar": {
         const inner = one(d.parser);
         out = parser({
@@ -19628,13 +19924,15 @@ function rebuildCombinator(root, replacements) {
           frozen.push({ tag: d.tag, rule: here });
         }
         for (const t2 of subtreeContains(p, targets)) if (!unapplied.includes(t2)) unapplied.push(t2);
-        memo.set(p, p);
-        return p;
+        const kept = after(p, p);
+        memo.set(p, kept);
+        return kept;
       }
     }
     carryStamps(p, out);
-    memo.set(p, out);
-    return out;
+    const done = after(p, out);
+    memo.set(p, done);
+    return done;
   };
   const rebuilt = go(root, root._ruleName ?? "<entry>");
   frozen.sort((a, b) => a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : a.tag < b.tag ? -1 : a.tag > b.tag ? 1 : 0);
@@ -20871,9 +21169,715 @@ function measureChoiceCost(c, samples, arms) {
 function armFirstSets(choiceArms2) {
   return choiceArms2.map((a) => ({ firstSet: firstSetOf(a) }));
 }
+
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+var SELECTED_ROOT_STRIDE = 5;
+function buildRootTriviaIndex(log, labels) {
+  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
+  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
+  const ownedRangeStart = (i) => log[markerOffset(i)];
+  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
+  const markerStart = (i) => log[markerOffset(i) + 2];
+  const markerEnd = (i) => log[markerOffset(i) + 3];
+  const markerKind = (i) => log[markerOffset(i) + 4];
+  const entries = {
+    length,
+    labels,
+    stride: SELECTED_ROOT_STRIDE,
+    start: markerStart,
+    end: markerEnd,
+    insertIndex: () => void 0,
+    kindIndex: markerKind,
+    kind(i) {
+      return labels[markerKind(i)];
+    },
+    text(i, input) {
+      return input.slice(markerStart(i), markerEnd(i));
+    }
+  };
+  const lowerBound = (offset, by) => {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (by(mid) < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const gapRowsAt = (offset, direction) => {
+    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
+    let first = lowerBound(offset, edge);
+    if (first === length || edge(first) !== offset) return void 0;
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
+    let last = first + 1;
+    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
+    return [first, last];
+  };
+  const indices = (first, last) => {
+    const out = [];
+    for (let i = first; i < last; i++) out.push(i);
+    return out;
+  };
+  const makeGap = (first, last) => {
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    let entryIndices;
+    return {
+      start,
+      end,
+      get entryIndices() {
+        return entryIndices ??= indices(first, last);
+      },
+      hasKind(kind) {
+        for (let i = first; i < last; i++) {
+          if (labels[markerKind(i)] === kind) return true;
+        }
+        return false;
+      },
+      text(input) {
+        return input.slice(start, end);
+      }
+    };
+  };
+  let maps;
+  const getMaps = () => {
+    if (maps !== void 0) return maps;
+    const before = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    const beforeGaps = /* @__PURE__ */ new Map();
+    const afterGaps = /* @__PURE__ */ new Map();
+    const gaps = [];
+    for (let first = 0; first < length; ) {
+      let last = first + 1;
+      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+      const gap = makeGap(first, last);
+      gaps.push(gap);
+      afterGaps.set(gap.start, gap);
+      beforeGaps.set(gap.end, gap);
+      after.set(gap.start, [...gap.entryIndices]);
+      before.set(gap.end, [...gap.entryIndices]);
+      first = last;
+    }
+    maps = { before, after, beforeGaps, afterGaps, gaps };
+    return maps;
+  };
+  return {
+    entries,
+    labels,
+    get before() {
+      return getMaps().before;
+    },
+    get after() {
+      return getMaps().after;
+    },
+    entryIndicesBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    entryIndicesAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    gapBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gapAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gaps() {
+      return getMaps().gaps;
+    },
+    gapsWithKind(kind) {
+      const kinds = typeof kind === "string" ? [kind] : kind;
+      const matches2 = [];
+      for (let first = 0; first < length; ) {
+        let last = first + 1;
+        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+        let matched = false;
+        for (let i = first; i < last && !matched; i++) {
+          const label2 = labels[markerKind(i)];
+          for (const kind2 of kinds) {
+            if (label2 === kind2) {
+              matched = true;
+              break;
+            }
+          }
+        }
+        if (matched) matches2.push(makeGap(first, last));
+        first = last;
+      }
+      return matches2.length === 0 ? EMPTY_GAPS : matches2;
+    }
+  };
+}
+
+// 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\`.`
+  ]
+];
+var RunResultRecord = class {
+  constructor(ok, value, span, expected, errors, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+var RunResultWithRootTrivia = class {
+  constructor(ok, value, span, expected, errors, rootTrivia, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.rootTrivia = rootTrivia;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+for (const proto of [RunResultRecord.prototype, RunResultWithRootTrivia.prototype]) {
+  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
+    Object.defineProperty(proto, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        throw new TypeError(
+          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
+        );
+      }
+    });
+  }
+}
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function ambientTriviaFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.grammarTrivia;
+  if (r._meta.isTrivia) return void 0;
+  return r._meta.grammarTrivia ?? (r._def.tag === "grammar" ? r._def.triviaParser : void 0);
+}
+function triviaKindLabelsFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.triviaKindLabels;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
+}
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
+  }
+  return index;
+}
+function growSpanEnd(span, input, end) {
+  if (span.endLine === void 0 || span.endColumn === void 0) {
+    return { start: span.start, end };
+  }
+  let line = span.endLine;
+  let column = span.endColumn;
+  for (let i = span.end; i < end; i++) {
+    if (input.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { ...span, end, endLine: line, endColumn: column };
+}
+function runOnce(entry, input, options) {
+  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
+    throw new TypeError(
+      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
+    );
+  }
+  const rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
+  const errors = [];
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
+  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
+  }
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
+  }
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
+  }
+  const stamped = entry;
+  assertHostModeCompatible(
+    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
+    options.build,
+    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
+  );
+  const ctx = createParseContext();
+  if (captureRootTrivia) {
+    ctx._rootTriviaLog = selectedRootLog;
+    ctx._rootTriviaKindIndex = selectedRootLabelIndex;
+    ctx._rootTriviaStrictScopes = true;
+  }
+  ctx._errors = errors;
+  ctx.build = options.build;
+  ctx.state = options.state;
+  if (grammarTrivia !== void 0) ctx.trivia = grammarTrivia;
+  if (triviaKindLabels) ctx.triviaKindLabels = triviaKindLabels;
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (options.triviaCaptureMask !== void 0) ctx._triviaCaptureMask = options.triviaCaptureMask;
+  if (options.tolerant) {
+    ctx._tolerant = true;
+    ctx._rec = REC;
+  }
+  if (options.instrumentation !== void 0) {
+    ctx._grammarCoverage = options.instrumentation._grammarCoverage;
+    ctx._grammarTrace = options.instrumentation._grammarTrace;
+  }
+  const r = invoke(entry, input, 0, ctx);
+  const value = r.ok ? r.value : void 0;
+  let span = r.span ?? { start: 0, end: 0 };
+  const expected = r.ok ? [] : [...new Set(r.expected ?? [])];
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = span.end;
+    const tail = options.trivia ?? ambientTriviaFromRunnable(entry);
+    if (tail !== void 0 && pos < input.length) {
+      const t2 = invoke(tail, input, pos, createParseContext());
+      if (t2.ok && t2.span.end > pos) {
+        span = growSpanEnd(span, input, t2.span.end);
+        pos = t2.span.end;
+      }
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
+  }
+  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
+    r.ok,
+    value,
+    span,
+    expected,
+    errors,
+    {
+      rows: selectedRootLog,
+      select: rootTriviaSelection,
+      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+    },
+    unconsumedFrom
+  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
+}
+function run(entry, input, options = {}) {
+  return runOnce(entry, input, options);
+}
+
+// src/table/backtrack-probe.ts
+var LOOKAROUND = /(?<!\\)\(\?<?[=!]/;
+function hasLookaround(re) {
+  return LOOKAROUND.test(re.source);
+}
+function lookaroundExtent(re, input, start, end) {
+  const probe2 = new RegExp(re.source, re.flags.includes("y") ? re.flags : `${re.flags}y`);
+  const same = (n) => {
+    probe2.lastIndex = start;
+    return probe2.test(input.slice(0, end + n)) && probe2.lastIndex === end;
+  };
+  let lo = 0;
+  let hi = input.length - end;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (same(mid)) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+}
+var BacktrackRecorder = class {
+  input = "";
+  counts = zeroCounts();
+  look = 0;
+  opaque = 0;
+  last = 0;
+  furthest = 0;
+  begin(input) {
+    this.input = input;
+    this.counts = zeroCounts();
+    this.look = 0;
+    this.opaque = 0;
+    this.last = 0;
+    this.furthest = 0;
+  }
+  /** The counts for the parse `begin` opened. Throws if a region was left open. */
+  end() {
+    if (this.look !== 0 || this.opaque !== 0) {
+      throw new Error(`backtrack probe: unbalanced region (lookahead ${this.look}, opaque ${this.opaque})`);
+    }
+    return this.counts;
+  }
+  consume(start, end) {
+    if (this.opaque > 0 || end <= start) return;
+    const c = this.counts;
+    if (this.look > 0) {
+      c.lookaheadBytes += end - start;
+      return;
+    }
+    if (start < this.last) c.rewinds++;
+    if (start < this.furthest) c.bytesReread += Math.min(end, this.furthest) - start;
+    this.last = end;
+    if (end > this.furthest) this.furthest = end;
+  }
+  enterLookahead() {
+    if (this.opaque === 0) this.counts.lookaheads++;
+    this.look++;
+  }
+  exitLookahead() {
+    this.look--;
+  }
+  regexAttempt() {
+    if (this.opaque === 0) this.counts.regexLookarounds++;
+  }
+  regexMatch(re, start, end) {
+    if (this.opaque === 0) this.counts.regexLookaroundBytes += lookaroundExtent(re, this.input, start, end);
+    this.consume(start, end);
+  }
+  /** A read whose inner steps are not the grammar's (the interpreter's scans). */
+  enterOpaque() {
+    this.opaque++;
+  }
+  exitOpaque() {
+    this.opaque--;
+  }
+};
+function zeroCounts() {
+  return { rewinds: 0, bytesReread: 0, lookaheads: 0, lookaheadBytes: 0, regexLookarounds: 0, regexLookaroundBytes: 0 };
+}
+function rowStarts(code, roots) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [...roots];
+  const kids = [];
+  while (stack.length > 0) {
+    const ip = stack.pop();
+    if (seen.has(ip)) continue;
+    seen.add(ip);
+    kids.length = 0;
+    childSlots(code, ip, kids);
+    for (const c of kids) stack.push(c);
+  }
+  return [...seen, code.length].sort((a, b) => a - b);
+}
+function probeProgram(source, rec) {
+  const prog = expandCompact(source);
+  const code = [...prog.code];
+  const fns = [...prog.fns];
+  const fx = [...prog.fx, []];
+  const noFx = fx.length - 1;
+  const row = (...words) => {
+    const ip = code.length;
+    code.push(...words);
+    return ip;
+  };
+  const fn = (f) => fns.push(f) - 1;
+  const slots = [];
+  const extraIps = assemblyExtraIps(prog);
+  const starts = rowStarts(prog.code, [...Object.values(prog.rules), ...extraIps]);
+  const copies = /* @__PURE__ */ new Map();
+  function copyOf(ip) {
+    const hit = copies.get(ip);
+    if (hit !== void 0) return hit;
+    slots.length = 0;
+    childSlotOffsets(prog.code, ip, slots);
+    if (slots.length === 0) {
+      copies.set(ip, ip);
+      return ip;
+    }
+    const next = starts[starts.findIndex((s) => s > ip)];
+    const at = code.length;
+    copies.set(ip, at);
+    for (let i = ip; i < next; i++) code.push(prog.code[i]);
+    const own = slots.map((s) => s - ip);
+    for (const o of own) code[at + o] = copyOf(prog.code[ip + o]);
+    return at;
+  }
+  const ref2 = (r) => [copyOf(r[0]), r[1]];
+  const scans = prog.scans?.map((s) => ({
+    ...s,
+    skip: s.skip.map(ref2),
+    ...s.sentinel === void 0 ? {} : { sentinel: ref2(s.sentinel) },
+    ...s.recoverAt === void 0 ? {} : { recoverAt: ref2(s.recoverAt) },
+    ...s.stopAt === void 0 ? {} : { stopAt: ref2(s.stopAt) },
+    ...s.prefix === void 0 ? {} : { prefix: ref2(s.prefix) },
+    ...s.body === void 0 ? {} : { body: ref2(s.body) },
+    ...s.first === void 0 ? {} : { first: ref2(s.first) },
+    ...s.lazy === void 0 ? {} : { lazy: ref2(s.lazy) }
+  }));
+  const scanSkip = prog.scanSkip?.map((set) => set.map(ref2));
+  const report = fn((v, span) => {
+    rec.consume(span.start, span.end);
+    return v;
+  });
+  const lookIn = fn(() => {
+    rec.enterLookahead();
+    return true;
+  });
+  const lookOut = fn((v) => {
+    rec.exitLookahead();
+    return v;
+  });
+  const regexTry = fn(() => {
+    rec.regexAttempt();
+    return true;
+  });
+  const lookahead = (child, fxi) => row(
+    OP_ARMGATE,
+    lookIn,
+    row(OP_XFORM, lookOut, row(OP_NOT, row(OP_XFORM, lookOut, replacement(child) ?? child), fxi)),
+    noFx
+  );
+  const replaced = /* @__PURE__ */ new Map();
+  function replacement(c) {
+    const hit = replaced.get(c);
+    if (hit !== void 0) return hit;
+    let r;
+    switch (code[c]) {
+      case OP_LIT:
+      case OP_LIT_TRACK:
+      case OP_LIT_CI:
+      case OP_LIT_CI_TRACK:
+      case OP_LEX_BODY:
+      case OP_LEX_PROGRAM:
+      case OP_SCAN:
+      case OP_LIVE:
+        r = row(OP_XFORM, report, c);
+        break;
+      case OP_RX:
+      case OP_RX_TRACK: {
+        const re = prog.k[code[c + 1]];
+        r = hasLookaround(re) ? row(
+          OP_ARMGATE,
+          regexTry,
+          row(OP_XFORM, fn((v, span) => {
+            rec.regexMatch(re, span.start, span.end);
+            return v;
+          }), c),
+          noFx
+        ) : row(OP_XFORM, report, c);
+        break;
+      }
+      case OP_NOT:
+        r = lookahead(code[c + 1], code[c + 2]);
+        break;
+      case OP_PEEK:
+        r = row(OP_NOT, lookahead(code[c + 1], code[c + 2]), code[c + 2]);
+        break;
+    }
+    if (r !== void 0) replaced.set(c, r);
+    return r;
+  }
+  const rules = {};
+  const stack = [];
+  for (const [name, ip] of Object.entries(prog.rules)) {
+    rules[name] = replacement(ip) ?? ip;
+    stack.push(ip);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const ip = stack.pop();
+    if (seen.has(ip)) continue;
+    seen.add(ip);
+    slots.length = 0;
+    if (!childSlotOffsets(code, ip, slots)) throw new Error(`backtrack probe: unknown opcode ${String(code[ip])} at ${ip}`);
+    for (let i = 0; i < slots.length; i++) {
+      const s = slots[i];
+      const c = code[s];
+      stack.push(c);
+      if (code[ip] === OP_GREEDY && i > 0) continue;
+      const r = replacement(c);
+      if (r !== void 0) code[s] = r;
+    }
+  }
+  const out = Object.fromEntries(Object.entries(prog));
+  return {
+    ...out,
+    code,
+    fns,
+    fx,
+    rules,
+    asm: [],
+    ...scans === void 0 ? {} : { scans },
+    ...scanSkip === void 0 ? {} : { scanSkip }
+  };
+}
+
+// src/analysis/backtrack.ts
+function isCombinator3(x) {
+  return typeof x === "object" && x !== null && "_def" in x && typeof x.parse === "function";
+}
+function isProgram(x) {
+  return Array.isArray(x.code) || Array.isArray(x.c);
+}
+function ruleEntries(grammar) {
+  const out = [];
+  for (const [name, value] of Object.entries(grammar)) {
+    if (!isCombinator3(value)) continue;
+    if (value._def.tag === "lazy") {
+      try {
+        value._def.thunk();
+      } catch {
+        continue;
+      }
+    }
+    out.push([name, value]);
+  }
+  return out;
+}
+function outcome(r) {
+  return digestValue({ ok: r.ok, value: r.value, span: r.span, unconsumedFrom: r.unconsumedFrom });
+}
+function tableOf(grammar) {
+  if (isProgram(grammar)) return expandCompact(grammar);
+  const refusals = [];
+  const compiled = compileRuleMapRunnable(ruleEntries(grammar), { refusals });
+  if (compiled === null) throw new Error(`backtrackProbe: this grammar could not be encoded to a table: ${refusals.join("; ")}`);
+  return compiled.prog;
+}
+function backtrackProbe(grammar, engine = "closure") {
+  const rec = new BacktrackRecorder();
+  if (engine === "interpreter") {
+    if (isProgram(grammar)) throw new TypeError("backtrackProbe: the interpreter runs a rule map of combinators, not a table program");
+    const rules2 = Object.fromEntries(ruleEntries(grammar));
+    const built = /* @__PURE__ */ new Map();
+    const instrument = instrumentFor(rec);
+    return probe(rec, "interpreter", (entry) => ruleOf(rules2, entry), (entry) => {
+      let hit = built.get(entry);
+      if (hit === void 0) {
+        hit = rebuildCombinator(ruleOf(rules2, entry), /* @__PURE__ */ new Map(), { thaw: true, after: instrument }).root;
+        built.set(entry, hit);
+      }
+      return hit;
+    });
+  }
+  if (engine !== "closure") throw new TypeError(`backtrackProbe: no engine ${JSON.stringify(engine)}; it runs 'closure' or 'interpreter'`);
+  const prog = tableOf(grammar);
+  const base = tableRules({ ...prog, asm: [] });
+  const rules = tableRules(probeProgram(prog, rec));
+  return probe(rec, "closure", (entry) => ruleOf(base, entry), (entry) => ruleOf(rules, entry));
+}
+function probe(rec, ran, plain2, probed) {
+  return {
+    engine: { ran },
+    measure(entry, input, options = {}) {
+      const result = run(plain2(entry), input, options);
+      rec.begin(input);
+      const probedResult = run(probed(entry), input, options);
+      const counts = rec.end();
+      if (outcome(probedResult) !== outcome(result)) {
+        throw new Error(`backtrackProbe: the probed ${ran} parse of rule ${JSON.stringify(entry)} differs from the plain one; its counts would describe another parse`);
+      }
+      return { result, counts };
+    }
+  };
+}
+function ruleOf(rules, entry) {
+  if (!Object.hasOwn(rules, entry)) throw new Error(`backtrackProbe: the grammar has no rule ${JSON.stringify(entry)}`);
+  return rules[entry];
+}
+function wrapped(out, parse2) {
+  const w = { _tag: out._tag, _meta: out._meta, _def: out._def, parse: parse2 };
+  const name = out._ruleName;
+  if (name !== void 0) w._ruleName = name;
+  return w;
+}
+function instrumentFor(rec) {
+  return (_original, out) => {
+    const d = out._def;
+    switch (d.tag) {
+      case "literal":
+      case "keywords":
+        return wrapped(out, (input, pos, ctx) => {
+          const r = out.parse(input, pos, ctx);
+          if (r.ok) rec.consume(r.span.start, r.span.end);
+          return r;
+        });
+      case "regex": {
+        const re = new RegExp(d.source, d.flags);
+        if (!hasLookaround(re)) {
+          return wrapped(out, (input, pos, ctx) => {
+            const r = out.parse(input, pos, ctx);
+            if (r.ok) rec.consume(r.span.start, r.span.end);
+            return r;
+          });
+        }
+        return wrapped(out, (input, pos, ctx) => {
+          rec.regexAttempt();
+          const r = out.parse(input, pos, ctx);
+          if (r.ok) rec.regexMatch(re, r.span.start, r.span.end);
+          return r;
+        });
+      }
+      case "scanTo":
+      case "lines":
+      case "columns":
+      case "recover":
+      case "unknown":
+        return wrapped(out, (input, pos, ctx) => {
+          rec.enterOpaque();
+          let r;
+          try {
+            r = out.parse(input, pos, ctx);
+          } finally {
+            rec.exitOpaque();
+          }
+          if (r.ok) rec.consume(r.span.start, r.span.end);
+          return r;
+        });
+      case "not":
+      case "peek":
+        return wrapped(out, (input, pos, ctx) => {
+          rec.enterLookahead();
+          try {
+            return out.parse(input, pos, ctx);
+          } finally {
+            rec.exitLookahead();
+          }
+        });
+      default:
+        return out;
+    }
+  };
+}
 export {
   applyFixEdits,
   armFirstSets,
+  backtrackProbe,
   diagnosisLines,
   fixReportLines,
   groupDigits,