parseman 0.60.6 → 0.61.1

package/dist/cli/index.js

@@ -2552,6 +2552,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 PlainLeaf2(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/recovery/scan.ts
 import { PlainSpan as PlainSpan2 } from "../cst/plain.js";
@@ -2718,6 +2918,7 @@ function derive(c, seen) {
     case "optional":
     case "many":
     case "oneOrMore":
+    case "sepBy":
     case "transform":
     case "not":
     case "peek":
@@ -2899,7 +3100,7 @@ function selectOptionalSuffixLexBody(ir) {
 function reinstallsRuleTrivia(reference, target) {
   return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
 }
-function directTokenBodyParser(parser2, resolve2, scope) {
+function directTokenBodyParser(parser2, resolve2, scope2) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -2909,7 +3110,7 @@ function directTokenBodyParser(parser2, resolve2, 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;
     }
@@ -3166,10 +3367,10 @@ function directFixedLexNode(parser2, resolve2, active, pureOnly = false, cleared
   }
 }
 function directFixedTokenBody(parser2, resolve2) {
-  const scope = { cleared: false };
-  const body = directTokenBodyParser(parser2, resolve2, scope);
+  const scope2 = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve2, scope2);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve2, /* @__PURE__ */ new Set(), false, scope.cleared);
+  const root = directFixedLexNode(body, resolve2, /* @__PURE__ */ new Set(), false, scope2.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve2) {
@@ -4257,15 +4458,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;
@@ -4276,22 +4482,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);
@@ -4300,19 +4508,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:
@@ -4342,6 +4537,12 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// src/combinators/link-scope.ts
+var scope;
+function afterLink(settle) {
+  scope?.push(settle);
+}
+
 // src/cst/root-trivia-scope.ts
 var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
 function refuseUnclassifiedRootScope(strict) {
@@ -4598,7 +4799,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);
@@ -5498,6 +5699,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]];
@@ -6113,11 +6317,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,
@@ -7318,8 +7523,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 {
@@ -8845,7 +9056,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 = [];
@@ -8853,7 +9064,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) {
@@ -8869,7 +9080,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;
@@ -8883,7 +9094,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;
@@ -10199,6 +10410,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
@@ -10231,7 +10448,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:
@@ -10248,55 +10465,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;
@@ -13430,9 +13647,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";
 
@@ -16610,10 +16824,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");
@@ -16638,7 +16852,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,
@@ -17412,12 +17626,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,"] : [],
@@ -20250,6 +20467,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",
@@ -20263,6 +20512,7 @@ var FROZEN_TAGS = /* @__PURE__ */ new Set([
   "lines",
   "columns"
 ]);
+var THAWED_TAGS = /* @__PURE__ */ new Set(["dispatch", "withCtx", "routed", "guard"]);
 var CARRIED_META = [
   "grammarTrivia",
   "grammarScanSkip",
@@ -20301,7 +20551,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 = [];
@@ -20321,15 +20573,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;
@@ -20366,6 +20619,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)) {
@@ -20373,8 +20634,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);
@@ -20452,13 +20714,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({
@@ -20476,13 +20758,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);