parseman 0.61.0 → 0.61.1

package/dist/analysis/rebuild.d.ts

@@ -53,9 +53,25 @@ export type RebuildResult = {
      */
     unapplied: Combinator<unknown>[];
 };
+export type RebuildOptions = {
+    /**
+     * Also rebuild `dispatch`, a gated `choice`, `withCtx` and `routed` instead of
+     * freezing them. Each is reconstructed from its own def fields — the arms, gates,
+     * matchers and `extra` the grammar built it with. Off for `proposeFixes()`, whose
+     * reports name the frozen kinds; on for an instrumented rebuild, which must reach
+     * every terminal (`backtrack.ts`).
+     */
+    readonly thaw?: boolean;
+    /**
+     * Called with each node and what it was rebuilt to (itself, for a frozen or
+     * childless one), and its result is used in its place. Not called for a
+     * replacement or a `lazy` slot.
+     */
+    readonly after?: (original: Combinator<unknown>, rebuilt: Combinator<unknown>) => Combinator<unknown>;
+};
 /**
  * Rebuild `root`, replacing every combinator that is a key of `replacements` with its
  * value. The replacement is spliced WITHOUT descending into the original target.
  */
-export declare function rebuildCombinator(root: Combinator<unknown>, replacements: ReadonlyMap<Combinator<unknown>, Combinator<unknown>>): RebuildResult;
+export declare function rebuildCombinator(root: Combinator<unknown>, replacements: ReadonlyMap<Combinator<unknown>, Combinator<unknown>>, options?: RebuildOptions): RebuildResult;
 //# sourceMappingURL=rebuild.d.ts.map

package/dist/analysis/rebuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rebuild.d.ts","sourceRoot":"","sources":["../../src/analysis/rebuild.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AAuBxD,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;IACzB,wEAAwE;IACxE,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB;;;OAGG;IACH,SAAS,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;CACjC,CAAA;AA0CD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,YAAY,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,GAClE,aAAa,CAiKf"}
+{"version":3,"file":"rebuild.d.ts","sourceRoot":"","sources":["../../src/analysis/rebuild.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,aAAa,CAAA;AA4BxD,6DAA6D;AAC7D,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,CAAA;IACzB,wEAAwE;IACxE,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB;;;OAGG;IACH,SAAS,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAA;CACjC,CAAA;AA0CD,MAAM,MAAM,cAAc,GAAG;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;IACvB;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,UAAU,CAAC,OAAO,CAAC,CAAA;CACtG,CAAA;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,YAAY,EAAE,WAAW,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,EACnE,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA8Lf"}

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";
@@ -5500,7 +5700,7 @@ function regex(pattern, flags = "") {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.61.0";
+var PARSEMAN_VERSION = "0.61.1";
 
 // src/table/lex-body.ts
 function buildLexBodyRecognizer(spec, constants) {
@@ -8856,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 = [];
@@ -8864,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) {
@@ -8880,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;
@@ -8894,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;
@@ -10210,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
@@ -10242,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:
@@ -10259,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;
@@ -16618,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");
@@ -16646,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,
@@ -20261,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",
@@ -20274,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",
@@ -20312,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 = [];
@@ -20332,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;
@@ -20377,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)) {
@@ -20384,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);
@@ -20463,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({
@@ -20487,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);