parseman 0.38.0 → 0.39.1

package/dist/plugin/index.js

@@ -59,6 +59,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       return d.value.length === 0;
     case "keywords":
       return false;
+    case "routed":
+      return false;
     case "regex":
       try {
         const m = new RegExp(d.source).exec("");
@@ -85,6 +87,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       return d.parsers.every(me);
     case "choice":
       return d.parsers.some(me);
+    case "dispatch":
+      return me(d.selector);
     case "transform":
     case "label":
     case "trivia":
@@ -158,6 +162,8 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
     case "keywords":
       return p._meta.firstSet;
     // terminals: no refs, cached set is exact
+    case "dispatch":
+      return fs2(d.selector);
     case "lazy":
       try {
         return fs2(d.thunk());
@@ -1106,6 +1112,8 @@ function derive(c, seen) {
       return [def.label];
     case "choice":
       return def.parsers.flatMap(deriveExpected2);
+    case "dispatch":
+      return deriveExpected2(def.selector);
     // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
     // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
     // able to fail first — deriving from term 0 alone named a token the parse
@@ -1145,6 +1153,8 @@ function derive(c, seen) {
     case "not":
     case "peek":
       return deriveExpected2(def.parser);
+    case "routed":
+      return ["routed()"];
     case "lazy": {
       const name = c._ruleName;
       if (seen.has(c)) return name ? [name] : [];
@@ -1244,6 +1254,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 };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
         return {
@@ -1284,6 +1295,7 @@ function choice(...args) {
           rollbackCstCapture(ctx, mark);
           if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
           expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           continue;
         }
         const checks = autoNot[i];
@@ -1963,6 +1975,245 @@ function sequence(...parsers) {
   };
 }
 
+// src/combinators/dispatch.ts
+function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(parser2)) return false;
+  seen.add(parser2);
+  const def = parser2._def;
+  switch (def.tag) {
+    case "routed":
+      return true;
+    case "sequence":
+    case "choice":
+      return def.parsers.some((entry) => parserUsesRouted(entry, seen));
+    case "dispatch":
+      return false;
+    case "sepBy":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.separator, seen);
+    case "skip":
+      return parserUsesRouted(def.main, seen) || parserUsesRouted(def.skipped, seen);
+    case "grammar":
+      return parserUsesRouted(def.parser, seen) || (def.triviaParser ? parserUsesRouted(def.triviaParser, seen) : false);
+    case "scanTo":
+      return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen));
+    case "recover":
+      return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
+    case "lazy":
+      try {
+        return parserUsesRouted(def.thunk(), seen);
+      } catch {
+        return false;
+      }
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "expect":
+      return parserUsesRouted(def.parser, seen);
+    default:
+      return false;
+  }
+}
+function branchUsesRouted(branch) {
+  return branch.usesRouted === true || parserUsesRouted(branch.parser);
+}
+function asciiFoldKey(key) {
+  let out = "";
+  for (let i = 0; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+  }
+  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 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) {
+  return { kind: "otherwise", parser: parser2, usesRouted: parserUsesRouted(parser2) };
+}
+function routed() {
+  return {
+    _tag: "routed",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "routed" },
+    parse(_input, pos, ctx) {
+      const item = ctx._routed;
+      if (item === void 0) {
+        return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
+      }
+      if (pos !== item.span.start) {
+        return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
+      }
+      if (cstCaptureActive(ctx)) {
+        pushCstLeaf(ctx, { _tag: "leaf", value: item.value, span: 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;
+  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;
+      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 } : {} }
+    },
+    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 branch = byKey.get(selected.value) ?? (byFoldedKey.size === 0 ? void 0 : byFoldedKey.get(asciiFoldKey(selected.value))) ?? matchers.find((matcher) => matchesDispatchMatcher(selected.value, matcher)) ?? (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 { ...result, committed: true };
+      }
+      return {
+        ok: true,
+        value: [selected.value, result.value],
+        span: { start: pos, end: result.span.end }
+      };
+    }
+  };
+}
+
 // src/combinators/attempt.ts
 function attempt(parser2) {
   const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
@@ -1985,6 +2236,7 @@ function attempt(parser2) {
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (result.committed) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
   };
@@ -2014,6 +2266,7 @@ function repItem(combinator, input, cur, ctx, guardable) {
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
     rollbackTrivia(ctx, mark);
+    if (result.committed) return { fail: result, failPos: pos };
     return { fail: result, failPos: pos };
   }
   if (result.span.end === pos) {
@@ -2057,6 +2310,7 @@ function many(combinator, opts = {}) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -2101,6 +2355,7 @@ function atLeast(combinator, min, max) {
       while (count < min) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop" || "fail" in item) {
+          if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
           expected ??= deriveExpected(combinator);
           return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
         }
@@ -2113,6 +2368,7 @@ function atLeast(combinator, min, max) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -2151,6 +2407,7 @@ function optional(combinator) {
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackTrivia(ctx, mark);
+      if (result.committed) return result;
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
   };
@@ -2190,6 +2447,7 @@ function sepBy(combinator, separator, opts = {}) {
         values.push(first.value);
         cur = first.span.end;
       } else {
+        if (first.committed) return first;
         const term = ctx._tolerant ? ctx._sync : void 0;
         if (term === void 0 || matchesAt(term, input, pos, ctx)) {
           if (min >= 1) return failAt2(pos);
@@ -2217,6 +2475,7 @@ function sepBy(combinator, separator, opts = {}) {
         const sep2 = separator.parse(input, sepPos, ctx);
         if (!sep2.ok) {
           rollbackTrivia(ctx, loopMark);
+          if (sep2.committed) return sep2;
           break;
         }
         const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
@@ -2232,6 +2491,7 @@ function sepBy(combinator, separator, opts = {}) {
         }
         const next = combinator.parse(input, nextPos, ctx);
         if (!next.ok) {
+          if (next.committed) return next;
           const term = ctx._tolerant ? ctx._sync : void 0;
           if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
             expected ??= deriveExpected(combinator);
@@ -2287,6 +2547,12 @@ function markUnusedValues(root) {
       case "choice":
         for (const p of def.parsers) visit(p, consumed);
         return;
+      case "dispatch":
+        visit(def.selector, consumed);
+        for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
+        if (def.otherwise) visit(def.otherwise, consumed);
+        return;
       case "node":
         visit(def.parser, false);
         return;
@@ -2562,6 +2828,8 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
     case "sequence":
     case "choice":
       return d.parsers.some((x) => parserHasOwnFields(x, seen));
+    case "dispatch":
+      return parserHasOwnFields(d.selector, seen) || d.cases.some((x) => parserHasOwnFields(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserHasOwnFields(entry.parser, seen)) : false) || (d.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
     case "sepBy":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
     case "skip":
@@ -2629,6 +2897,8 @@ function parserHasTriviaSite(p, seen = /* @__PURE__ */ new Set()) {
       return parserHasTriviaSite(d.parser, seen);
     case "choice":
       return d.parsers.some((x) => parserHasTriviaSite(x, seen));
+    case "dispatch":
+      return parserHasTriviaSite(d.selector, seen) || d.cases.some((x) => parserHasTriviaSite(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserHasTriviaSite(entry.parser, seen)) : false) || (d.otherwise ? parserHasTriviaSite(d.otherwise, seen) : false);
     case "grammar":
       return parserHasTriviaSite(d.parser, seen);
     case "lazy": {
@@ -2654,6 +2924,8 @@ function parserEnablesTriviaCapture(p, seen = /* @__PURE__ */ new Set()) {
     case "sequence":
     case "choice":
       return d.parsers.some((x) => parserEnablesTriviaCapture(x, seen));
+    case "dispatch":
+      return parserEnablesTriviaCapture(d.selector, seen) || d.cases.some((x) => parserEnablesTriviaCapture(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => parserEnablesTriviaCapture(entry.parser, seen)) : false) || (d.otherwise ? parserEnablesTriviaCapture(d.otherwise, seen) : false);
     case "sepBy":
       return parserEnablesTriviaCapture(d.parser, seen) || parserEnablesTriviaCapture(d.separator, seen);
     case "skip":
@@ -3028,7 +3300,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.38.0";
+var PARSEMAN_VERSION = "0.39.1";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3184,6 +3456,8 @@ function classifyBroadArm(arm, resolve2) {
         }
         return null;
       }
+      case "dispatch":
+        return walk2(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
@@ -3283,6 +3557,12 @@ function analyzeGatingRules(ruleMap, opts) {
     if (Array.isArray(rec.parsers)) kids.push(...rec.parsers);
     for (const k of ["parser", "main", "skipped", "separator", "sentinel"])
       if (rec[k]) kids.push(rec[k]);
+    if (d.tag === "dispatch") {
+      kids.push(d.selector);
+      for (const c of d.cases) kids.push(c.parser);
+      if (d.matchers) for (const c of d.matchers) kids.push(c.parser);
+      if (d.otherwise !== void 0) kids.push(d.otherwise);
+    }
     if (Array.isArray(rec.skip)) kids.push(...rec.skip);
     if (d.tag === "lazy") {
       try {
@@ -3389,6 +3669,12 @@ function childrenOf(d) {
     case "sequence":
     case "choice":
       return d.parsers;
+    case "dispatch":
+      return [
+        d.selector,
+        ...d.cases.map((c) => c.parser),
+        ...d.otherwise === void 0 ? [] : [d.otherwise]
+      ];
     case "skip":
       return [d.main, d.skipped];
     case "sepBy":
@@ -3445,6 +3731,8 @@ function payloadKey(p, d) {
       return `${d.tag}\0${d.min}\0${d.max ?? ""}`;
     case "sepBy":
       return `sepBy\0${d.min}\0${d.max ?? ""}\0${d.trailing ?? ""}`;
+    case "dispatch":
+      return `dispatch\0${d.cases.map((c) => JSON.stringify(c.keys)).join("")}\0${d.otherwise !== void 0}`;
     case "expect":
       return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
     case "scanTo":
@@ -3516,6 +3804,11 @@ function render(p, depth = 3) {
       return `sequence(${kids.join(", ")})`;
     case "choice":
       return `choice(${kids.join(", ")})`;
+    case "dispatch": {
+      const arms = d.cases.map((c, i) => `when([${c.keys.map((k) => JSON.stringify(k)).join(", ")}], ${kids[i + 1] ?? ""})`);
+      if (d.otherwise !== void 0) arms.push(`otherwise(${kids[kids.length - 1] ?? ""})`);
+      return `dispatch(${kids[0] ?? ""}, ${arms.join(", ")})`;
+    }
     case "node":
       return `node(${d.type ? `'${d.type}', ` : ""}${kids[0] ?? ""})`;
     case "label":
@@ -3539,6 +3832,10 @@ function segment(d, index) {
       return `seq[${index}]`;
     case "choice":
       return `choice[${index}]`;
+    case "dispatch":
+      if (index === 0) return "dispatch.selector";
+      if (index <= d.cases.length) return `dispatch.when[${index - 1}]`;
+      return "dispatch.otherwise";
     case "node":
       return `node(${d.type ?? ""})`;
     case "label":
@@ -4787,11 +5084,25 @@ function escapeClassChar(ch2) {
 }
 
 // src/compiler/grammar-coverage-ids.ts
+function idPart(value) {
+  return encodeURIComponent(value);
+}
+function dispatchArmIds(def, path2) {
+  const ids = [];
+  for (const entry of def.cases) ids.push(`dispatch:${path2}/when:${entry.keys.map(idPart).join("|")}`);
+  for (const entry of def.matchers ?? []) {
+    ids.push(`dispatch:${path2}/matcher:${entry.kind}:${idPart(entry.value)}${entry.kind === "matches" && entry.flags ? `:${idPart(entry.flags)}` : ""}`);
+  }
+  if (def.otherwise) ids.push(`dispatch:${path2}/otherwise`);
+  return ids;
+}
 function children(def, winners) {
   switch (def.tag) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.matchers ? def.matchers.map((entry) => entry.parser) : [], ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "oneOrMore":
     case "optional":
@@ -4834,6 +5145,7 @@ function children(def, winners) {
 function buildGrammarPlan(entry, winners) {
   const definitions = /* @__PURE__ */ new Map();
   const choices = /* @__PURE__ */ new WeakMap();
+  const dispatches = /* @__PURE__ */ new WeakMap();
   const attempts = /* @__PURE__ */ new WeakMap();
   const labels = /* @__PURE__ */ new WeakMap();
   const rules2 = /* @__PURE__ */ new WeakMap();
@@ -4864,6 +5176,11 @@ function buildGrammarPlan(entry, winners) {
       choices.set(parser2, ids);
       ids.forEach((id) => definitions.set(id, { id, kind: "choice-arm" }));
     }
+    if (parser2._def.tag === "dispatch") {
+      const ids = dispatchArmIds(parser2._def, path2);
+      dispatches.set(parser2, ids);
+      ids.forEach((id) => definitions.set(id, { id, kind: "dispatch-arm" }));
+    }
     if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path2}`);
     if (parser2._def.tag === "label") {
       const id = `label:${path2}`;
@@ -4876,7 +5193,7 @@ function buildGrammarPlan(entry, winners) {
   for (const root of roots) {
     visit(root, winnerNames.get(root) ?? root._ruleName ?? "entry");
   }
-  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, attempts, labels, rules: rules2 };
+  return { definitions: [...definitions.values()].sort((a, b) => a.id.localeCompare(b.id)), choices, dispatches, attempts, labels, rules: rules2 };
 }
 
 // src/compiler/scannable-run.ts
@@ -6250,12 +6567,15 @@ function leadingFirstSetRecipe(p, seen = /* @__PURE__ */ new Set()) {
       case "literal":
       case "regex":
       case "keywords":
+      case "routed":
         return { alts: [[seg(p._meta.firstSet, matchesEmpty(p))]] };
       case "choice": {
         const alts = [];
         for (const arm of d.parsers) alts.push(...rec(arm).alts);
         return { alts };
       }
+      case "dispatch":
+        return rec(d.selector);
       case "sequence": {
         const chain = [];
         for (const term of d.parsers) {
@@ -6338,6 +6658,9 @@ function failReturn(expected, posExpr) {
 function failReturnArr(expectedArr, posExpr) {
   return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
+function committedReturnArr(expectedArr, posExpr) {
+  return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} }, committed: true }`;
+}
 function hoistExpected(ctx, constArrSource) {
   let name = ctx.expectedMap.get(constArrSource);
   if (name === void 0) {
@@ -6374,15 +6697,22 @@ function failArrBody(ctx, expectedArr, posExpr, constant = true) {
   return probe + trace + failReturnArr(expectedArr, posExpr);
 }
 function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
-  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} } }`;
+  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} }, ...(_ctx._fc ? { committed: true } : {}) }`;
+}
+function committedFailBody(ctx, expectedArr = "_ctx._fx", posExpr = "_ctx._fe") {
+  if (ctx.failLabel) {
+    if (!ctx.recordFail) return `{ _ctx._fc = true; break ${ctx.failLabel} }`;
+    return `{ _ctx._fc = true; _ctx._fe = ${posExpr}; _ctx._fx = ${expectedArr}; break ${ctx.failLabel} }`;
+  }
+  return committedReturnArr(expectedArr, posExpr);
 }
 function propagateFailBody(ctx, srcCtx = "_ctx") {
   if (srcCtx !== "_ctx") {
     if (ctx.failLabel) {
       if (!ctx.recordFail) return `break ${ctx.failLabel}`;
-      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; break ${ctx.failLabel} }`;
+      return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; break ${ctx.failLabel} }`;
     }
-    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; ${resultFromRecorded()} }`;
+    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded()} }`;
   }
   if (ctx.failLabel) return `break ${ctx.failLabel}`;
   return resultFromRecorded();
@@ -6595,6 +6925,8 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
     // nothing committed remains.
     case "choice":
       return false;
+    case "dispatch":
+      return capturesLeaf(d.selector, seen) || d.cases.some((x) => mayLeavePartialCapture(x.parser, seen) || capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, seen) || capturesLeaf(x.parser, seen)) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, seen) || capturesLeaf(d.otherwise, seen) : false);
     case "attempt":
       return false;
     // optional never fails; many/oneOrMore only "fail" with zero captured items.
@@ -6639,6 +6971,50 @@ function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set()) {
       return true;
   }
 }
+function mayCommitFailure(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "dispatch":
+      return true;
+    case "choice":
+    case "sequence":
+      return d.parsers.some((x) => mayCommitFailure(x, seen));
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+      return mayCommitFailure(d.parser, seen);
+    case "sepBy":
+      return mayCommitFailure(d.parser, seen) || mayCommitFailure(d.separator, seen);
+    case "skip":
+      return mayCommitFailure(d.main, seen) || mayCommitFailure(d.skipped, seen);
+    case "token":
+    case "leaf":
+      return mayCommitFailure(d.parser, seen);
+    case "withCtx":
+      return mayCommitFailure(d.parser, seen);
+    case "scanTo":
+      return mayCommitFailure(d.sentinel, seen) || d.skip.some((x) => mayCommitFailure(x, seen));
+    case "lazy": {
+      try {
+        return mayCommitFailure(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
 function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
   seen.add(p);
@@ -6649,6 +7025,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "keywords":
     case "node":
     case "token":
+    case "routed":
     case "leaf":
       return true;
     case "not":
@@ -6660,6 +7037,8 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "sequence":
     case "choice":
       return d.parsers.some((x) => capturesLeaf(x, seen));
+    case "dispatch":
+      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
     case "sepBy":
       return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
     case "many":
@@ -6706,6 +7085,7 @@ function emitFallible(inner, ctx, pos, swallow = false) {
   ctx.recordFail = savedRecord;
   const ind0 = ind(ctx);
   const needsRollback = ctx.capturing && mayLeavePartialCapture(inner);
+  const mayCommit = mayCommitFailure(inner);
   const needsFieldRollback = needsRollback && parserHasOwnFields(inner);
   const mL = needsRollback ? v(ctx, "_fcl") : null;
   const mR = needsRollback ? v(ctx, "_fcr") : null;
@@ -6719,6 +7099,7 @@ function emitFallible(inner, ctx, pos, swallow = false) {
       `${ind0}const ${mTl} = _ctx._cstTriviaLog?.length ?? 0`,
       ...mF ? [`${ind0}const ${mF} = _ctx._fields?.length ?? 0`] : []
     ] : [],
+    ...mayCommit ? [`${ind0}_ctx._fc = false`] : [],
     `${ind0}${lbl}: {`,
     ...r.stmts,
     `${ind0}  ${valV} = ${r.valueVar}; ${endV} = ${r.endVar}; ${okV} = true`,
@@ -6727,7 +7108,7 @@ function emitFallible(inner, ctx, pos, swallow = false) {
       `${ind0}if (!${okV}) { ${captureRestoreBody(mL, mR, mTl, null, mF)} }`
     ] : []
   ];
-  return { stmts, okVar: okV, valVar: valV, endVar: endV };
+  return { stmts, okVar: okV, valVar: valV, endVar: endV, mayCommit };
 }
 var CHARCODE_CHAIN_MAX = 16;
 function emitLit(def, ctx, pos) {
@@ -7104,6 +7485,186 @@ function emitChoice(parser2, def, ctx, pos) {
   }
   return emitNonDisjoint(def, def.strategy, allExpected, ctx, pos, coverageBase);
 }
+function emitTailFallible(parser2, ctx, pos) {
+  const savedRecord = ctx.recordFail;
+  ctx.recordFail = true;
+  const out = emitFallible(parser2, ctx, pos);
+  ctx.recordFail = savedRecord;
+  return out;
+}
+function mayRecordRecoveryError(p, recovery, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "expect":
+    case "recover":
+      return true;
+    case "many":
+    case "oneOrMore":
+    case "sepBy":
+      return recovery || mayRecordRecoveryError(d.parser, recovery, seen);
+    case "choice":
+    case "sequence": {
+      for (const item of d.parsers) {
+        if (mayRecordRecoveryError(item, recovery, seen)) return true;
+      }
+      return false;
+    }
+    case "dispatch": {
+      if (mayRecordRecoveryError(d.selector, recovery, seen)) return true;
+      for (const item of d.cases) {
+        if (mayRecordRecoveryError(item.parser, recovery, seen)) return true;
+      }
+      if (d.matchers?.some((item) => mayRecordRecoveryError(item.parser, recovery, seen))) return true;
+      return d.otherwise ? mayRecordRecoveryError(d.otherwise, recovery, seen) : false;
+    }
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+    case "token":
+    case "leaf":
+    case "withCtx":
+    case "optional":
+      return mayRecordRecoveryError(d.parser, recovery, seen);
+    case "skip":
+      return mayRecordRecoveryError(d.main, recovery, seen) || mayRecordRecoveryError(d.skipped, recovery, seen);
+    case "scanTo":
+      if (mayRecordRecoveryError(d.sentinel, recovery, seen)) return true;
+      for (const item of d.skip) {
+        if (mayRecordRecoveryError(item, recovery, seen)) return true;
+      }
+      return false;
+    case "lazy": {
+      try {
+        return mayRecordRecoveryError(d.thunk(), recovery, seen);
+      } catch {
+        return true;
+      }
+    }
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+function emitDispatchCombinator(parser2, def, ctx, pos) {
+  if (parserUsesRouted2(def.selector)) {
+    throw new Error("parseman: routed() can only appear inside a dispatch() branch");
+  }
+  const coverageIds = ctx.coverage?.plan.dispatches.get(parser2) ?? [];
+  const branchUsesRouted2 = (entry) => entry.usesRouted === true || parserUsesRouted2(entry.parser);
+  const hasRoutedBranch = def.cases.some(branchUsesRouted2) || (def.matchers ? def.matchers.some(branchUsesRouted2) : false) || (def.otherwise ? def.otherwiseUsesRouted === true || parserUsesRouted2(def.otherwise) : false);
+  const selectorLeafMark = hasRoutedBranch ? v(ctx, "_dsl") : null;
+  const selectorRawMark = hasRoutedBranch ? v(ctx, "_dsr") : null;
+  const selectorTriviaMark = hasRoutedBranch ? v(ctx, "_dst") : null;
+  const selectorLogMark = hasRoutedBranch ? v(ctx, "_dsg") : null;
+  const selectorFieldMark = hasRoutedBranch ? v(ctx, "_dsf") : null;
+  const selectorErrorMark = hasRoutedBranch ? v(ctx, "_dse") : null;
+  const selector = emit(def.selector, ctx, pos);
+  const outV = v(ctx, "_dval");
+  const outE = v(ctx, "_dend");
+  const keyV = v(ctx, "_dkey");
+  const stmts = [
+    ...selectorLeafMark ? [
+      `${ind(ctx)}const ${selectorLeafMark} = _ctx._cstLeaves?.length ?? 0`,
+      `${ind(ctx)}const ${selectorRawMark} = _ctx._cstRawChildren?.length ?? 0`,
+      `${ind(ctx)}const ${selectorTriviaMark} = _ctx._cstTriviaLog?.length ?? 0`,
+      `${ind(ctx)}const ${selectorLogMark} = _ctx._triviaLog?.length ?? 0`,
+      `${ind(ctx)}const ${selectorFieldMark} = _ctx._fields?.length ?? 0`,
+      `${ind(ctx)}const ${selectorErrorMark} = _ctx._errors?.length ?? 0`
+    ] : [],
+    ...selector.stmts,
+    `${ind(ctx)}const ${keyV} = ${selector.valueVar}`,
+    `${ind(ctx)}let ${outV}, ${outE} = ${selector.endVar}`
+  ];
+  let wroteBranch = false;
+  const emitSelectedTail = (entry, keyword, condition, coverageId) => {
+    const parser3 = entry.parser;
+    const head = keyword === "else" ? `${ind(ctx)}else {` : `${ind(ctx)}${keyword} (${condition}) {`;
+    stmts.push(head);
+    ctx.indent++;
+    const usesRouted = branchUsesRouted2(entry);
+    const routedV = usesRouted ? v(ctx, "_drt") : null;
+    const mayError = mayRecordRecoveryError(parser3, !!ctx.recovery);
+    const errMark = mayError ? v(ctx, "_derr") : null;
+    const logMark = ctx.activeTrivia ? v(ctx, "_dlog") : null;
+    if (routedV) {
+      stmts.push(
+        `${ind(ctx)}const ${routedV} = _ctx._routed; _ctx._routed = { value: ${selector.valueVar}, span: { start: ${pos}, end: ${selector.endVar} } }`,
+        ...selectorLeafMark ? [
+          `${ind(ctx)}if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${selectorLeafMark}) _ctx._cstLeaves.length = ${selectorLeafMark}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${selectorRawMark}) _ctx._cstRawChildren.length = ${selectorRawMark}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${selectorTriviaMark}) _ctx._cstTriviaLog.length = ${selectorTriviaMark}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${selectorLogMark}) _ctx._triviaLog.length = ${selectorLogMark}; if (_ctx._fields && _ctx._fields.length !== ${selectorFieldMark}) _ctx._fields.length = ${selectorFieldMark}; if (_ctx._errors && _ctx._errors.length !== ${selectorErrorMark}) _ctx._errors.length = ${selectorErrorMark}`
+        ] : []
+      );
+    }
+    if (errMark) stmts.push(`${ind(ctx)}const ${errMark} = _ctx._errors?.length ?? 0`);
+    if (logMark) stmts.push(`${ind(ctx)}const ${logMark} = _ctx._triviaLog?.length ?? 0`);
+    const tail = emitTailFallible(parser3, ctx, usesRouted ? pos : selector.endVar);
+    stmts.push(...coverageAttempt(ctx, coverageId, pos));
+    const errorRollback = errMark ? `if (_ctx._errors && _ctx._errors.length !== ${errMark}) _ctx._errors.length = ${errMark}; ` : "";
+    const logRollback = logMark ? `if (_ctx._triviaLog && _ctx._triviaLog.length !== ${logMark}) _ctx._triviaLog.length = ${logMark}; ` : "";
+    const routedRollback = routedV ? `_ctx._routed = ${routedV}; ` : "";
+    const coverageFailure = coverageId === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(coverageId)}, phase: 'failure', offset: _ctx._fe }); `;
+    stmts.push(
+      ...tail.stmts,
+      `${ind(ctx)}if (!${tail.okVar}) { ${routedRollback}${errorRollback}${logRollback}${coverageFailure}${committedFailBody(ctx)} }`,
+      ...routedV ? [`${ind(ctx)}_ctx._routed = ${routedV}`] : [],
+      `${ind(ctx)}${outV} = [${selector.valueVar}, ${tail.valVar}]`,
+      `${ind(ctx)}${outE} = ${tail.endVar}`,
+      ...coverageHit(ctx, coverageId, pos, tail.endVar)
+    );
+    ctx.indent--;
+    stmts.push(`${ind(ctx)}}`);
+  };
+  let coverageIndex = 0;
+  for (const entry of def.cases) {
+    const condition = entry.keys.map((key) => emitDispatchKeyCondition(keyV, key, entry.caseInsensitive)).join(" || ");
+    emitSelectedTail(entry, wroteBranch ? "else if" : "if", condition, coverageIds[coverageIndex++]);
+    wroteBranch = true;
+  }
+  const emitMatcherTails = () => {
+    for (const matcher of def.matchers ?? []) {
+      emitSelectedTail(matcher, wroteBranch ? "else if" : "if", emitDispatchMatcherCondition(keyV, matcher), coverageIds[coverageIndex++]);
+      wroteBranch = true;
+    }
+  };
+  if (def.otherwise) {
+    emitMatcherTails();
+    const otherwiseEntry = { parser: def.otherwise, usesRouted: def.otherwiseUsesRouted };
+    if (wroteBranch) emitSelectedTail(otherwiseEntry, "else", void 0, coverageIds[coverageIndex++]);
+    else emitSelectedTail(otherwiseEntry, "if", "true", coverageIds[coverageIndex++]);
+  } else {
+    emitMatcherTails();
+    const expected = JSON.stringify(def.cases.flatMap((entry) => entry.keys.map((key) => JSON.stringify(key))));
+    const fail = failArrBody(ctx, expected, selector.endVar);
+    stmts.push(wroteBranch ? `${ind(ctx)}else { ${fail} }` : `${ind(ctx)}${fail}`);
+  }
+  return { stmts, valueVar: outV, endVar: outE };
+}
+function emitDispatchKeyCondition(valueVar, key, caseInsensitive) {
+  if (!caseInsensitive) return `${valueVar} === ${JSON.stringify(key)}`;
+  const parts = [`${valueVar}.length === ${key.length}`];
+  for (let i = 0; i < key.length; i++) {
+    parts.push(foldEq(`${valueVar}.charCodeAt(${i})`, key.charCodeAt(i)));
+  }
+  return parts.join(" && ");
+}
+function emitDispatchMatcherCondition(valueVar, matcher) {
+  if (matcher.kind === "matches") {
+    const flags = matcher.caseInsensitive && !matcher.flags?.includes("i") ? `${matcher.flags ?? ""}i` : matcher.flags ?? "";
+    return `${new RegExp(matcher.value, flags).toString()}.test(${valueVar})`;
+  }
+  const text = matcher.value;
+  const parts = [`${valueVar}.length >= ${text.length}`];
+  const offset = matcher.kind === "endsWith" ? `${valueVar}.length - ${text.length}` : "0";
+  for (let i = 0; i < text.length; i++) {
+    parts.push(matcher.caseInsensitive ? foldEq(`${valueVar}.charCodeAt(${offset}${i === 0 ? "" : ` + ${i}`})`, text.charCodeAt(i)) : `${valueVar}.charCodeAt(${offset}${i === 0 ? "" : ` + ${i}`}) === ${text.charCodeAt(i)}`);
+  }
+  return parts.join(" && ");
+}
 function emitGreedyClassify(def, superIndex, ctx, pos, coverageBase) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
@@ -7225,12 +7786,16 @@ function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
     const armHasAutoNot = !!(autoNot && autoNot.length > 0);
     const armNeedsRollback = ctx.capturing && (mayLeavePartialCapture(p) || armHasAutoNot && capturesLeaf(p));
     const armNeedsFieldRollback = armNeedsRollback && parserHasOwnFields(p);
+    const armMayRecordError = mayRecordRecoveryError(p, !!ctx.recovery);
     const markLeaves = armNeedsRollback ? v(ctx, "_cml") : null;
     const markRaw = armNeedsRollback ? v(ctx, "_cmr") : null;
     const markTl = armNeedsRollback ? v(ctx, "_cmtl") : null;
     const markLog = armNeedsRollback ? v(ctx, "_cmlg") : null;
     const markFields = armNeedsFieldRollback ? v(ctx, "_cmf") : null;
-    const rollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog, markFields) : "";
+    const markErrors = armMayRecordError ? v(ctx, "_cme") : null;
+    const captureRollback = markLeaves ? captureRestoreBody(markLeaves, markRaw, markTl, markLog, markFields) : "";
+    const errorRollback = markErrors ? `if (_ctx._errors && _ctx._errors.length !== ${markErrors}) _ctx._errors.length = ${markErrors}` : "";
+    const rollback = [captureRollback, errorRollback].filter(Boolean).join("; ");
     const failSlot = atStart ? staticFx : "_ctx._fx";
     stmts.push(`${ind0}if (${skipCond}) {`);
     if (fsGuard) stmts.push(`${ind(ctx)}if (${fsGuard}) {`);
@@ -7245,7 +7810,9 @@ function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
         ...markFields ? [`${ind(ctx)}const ${markFields} = _ctx._fields?.length ?? 0`] : []
       );
     }
-    const { stmts: armStmts, okVar, valVar, endVar } = emitFallible(p, ctx, pos, atStart);
+    if (markErrors) stmts.push(`${ind(ctx)}const ${markErrors} = _ctx._errors?.length ?? 0`);
+    const arm = emitFallible(p, ctx, pos, atStart);
+    const { stmts: armStmts, okVar, valVar, endVar } = arm;
     stmts.push(...armStmts);
     if (autoNot && autoNot.length > 0) {
       const anCode = v(ctx, "_anc");
@@ -7269,10 +7836,12 @@ function emitFirstMatch(def, ctx, pos, coverageBase, preStmts, armGuardPrefix) {
       stmts.push(`${ind(ctx)}}`);
       stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}; ${coverageBase === void 0 ? "" : `_ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'failure', offset: ${atStart ? pos : "_ctx._fe"} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'backtrack', offset: ${pos} });`} }`);
       if (rollback) stmts.push(`${ind(ctx)}if (!${resOkV}) { ${rollback} }`);
+      if (arm.mayCommit) stmts.push(`${ind(ctx)}if (!${resOkV} && _ctx._fc) ${committedFailBody(ctx)}`);
     } else {
       const rejectedFlush = autoRejectedV === void 0 ? "" : `; for (const _rejectedId of ${autoRejectedV}) { _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'failure', offset: ${pos} }); _ctx._grammarTrace?.write({ id: _rejectedId, phase: 'backtrack', offset: ${pos} }) }`;
       stmts.push(`${ind(ctx)}if (${okVar}) { ${resValV} = ${valVar}; ${resEndV} = ${endVar}; ${resOkV} = true${coverageBase === void 0 ? "" : `${rejectedFlush}; _ctx._grammarCoverage?.(${JSON.stringify(`${coverageBase}${i}`)}); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'selected', offset: ${pos}, end: ${endVar} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'success', offset: ${pos}, end: ${endVar} })`} }`);
       stmts.push(`${ind(ctx)}else { ${slots[i]} = ${failSlot}${rollback ? `; ${rollback}` : ""}${coverageBase === void 0 ? "" : `; _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'failure', offset: ${atStart ? pos : "_ctx._fe"} }); _ctx._grammarTrace?.write({ id: ${JSON.stringify(`${coverageBase}${i}`)}, phase: 'backtrack', offset: ${pos} })`} }`);
+      if (arm.mayCommit) stmts.push(`${ind(ctx)}if (!${resOkV} && _ctx._fc) ${committedFailBody(ctx)}`);
     }
     ctx.indent -= fsGuard ? 2 : 1;
     if (fsGuard) stmts.push(`${ind(ctx)}} else { ${slots[i]} = ${staticFx} }`);
@@ -7429,7 +7998,8 @@ function emitMany(def, ctx, pos) {
       `${ind(ctx)}if (!(${firstSetCond(lcV, def.parser._meta.firstSet)})) { ${rollback}break }`
     );
   }
-  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = emitFallible(def.parser, ctx, itemPos, true);
+  const iter = emitFallible(def.parser, ctx, itemPos, true);
+  const { stmts: iterStmts, okVar: iterOk, valVar: iterVal, endVar: iterEnd } = iter;
   stmts.push(...iterStmts);
   if (ctx.recovery) {
     const rrV = v(ctx, "_rr");
@@ -7448,7 +8018,8 @@ function emitMany(def, ctx, pos) {
       `${ind(ctx)}if (${iterEnd} <= ${itemPos}) { ${rollback}break }`
     );
   } else {
-    stmts.push(`${ind(ctx)}if (!${iterOk} || ${iterEnd} <= ${itemPos}) { ${rollback}break }`);
+    stmts.push(`${ind(ctx)}if (!${iterOk}) { ${rollback}${iter.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
+    stmts.push(`${ind(ctx)}if (${iterEnd} <= ${itemPos}) { ${rollback}break }`);
   }
   if (wantValue) stmts.push(`${ind(ctx)}${arrV}.push(${iterVal})`);
   else if (maxV !== null) stmts.push(`${ind(ctx)}${maxV}++`);
@@ -7460,10 +8031,12 @@ function emitMany(def, ctx, pos) {
 function emitOptional(def, ctx, pos) {
   const valV = v(ctx, "_opt");
   const endV = v(ctx, "_opte");
-  const { stmts: lblStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos, true);
+  const inner = emitFallible(def.parser, ctx, pos, true);
+  const { stmts: lblStmts, okVar, valVar, endVar } = inner;
   const ind0 = ind(ctx);
   const stmts = [
     ...lblStmts,
+    ...inner.mayCommit ? [`${ind0}if (!${okVar} && _ctx._fc) ${committedFailBody(ctx)}`] : [],
     `${ind0}const ${valV} = ${okVar} ? ${valVar} : null`,
     `${ind0}const ${endV} = ${okVar} ? ${endVar} : ${pos}`
   ];
@@ -7495,7 +8068,7 @@ function emitAttempt(p, def, ctx, pos) {
       ...preGuard,
       `${ind(ctx)}const ${leaves} = _ctx._cstLeaves?.length ?? 0, ${raw} = _ctx._cstRawChildren?.length ?? 0, ${trivia2} = _ctx._cstTriviaLog?.length ?? 0, ${log} = _ctx._triviaLog?.length ?? 0, ${fields} = _ctx._fields?.length ?? 0, ${errors} = _ctx._errors?.length ?? 0`,
       ...inner.stmts,
-      ...emitIfFail(ctx, `!${inner.okVar}`, `{ ${rollback};${traceRollback} _ctx._fe = ${pos}; ${propagateFailBody(ctx)} }`)
+      ...emitIfFail(ctx, `!${inner.okVar}`, `{ ${rollback};${traceRollback}${inner.mayCommit ? ` if (_ctx._fc) ${committedFailBody(ctx)};` : ""} _ctx._fe = ${pos}; ${propagateFailBody(ctx)} }`)
     ],
     valueVar: inner.valVar,
     endVar: inner.endVar
@@ -7509,18 +8082,21 @@ function emitSepBy(_p, def, ctx, pos) {
   const exp = rec ? hoistExpected(ctx, deriveExpectedArr([def.parser])) : "";
   const sepSent = rec ? syncSentinelExpr(firstSetOf(def.separator)) : null;
   const scanSync = sepSent ? `_ctx._rec.or(${sepSent}, ${mySyncV})` : mySyncV;
-  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = emitFallible(def.parser, ctx, pos, true);
+  const first = emitFallible(def.parser, ctx, pos, true);
+  const { stmts: firstStmts, okVar: firstOk, valVar: firstVal, endVar: firstEnd } = first;
   const stmts = [
     `${ind(ctx)}const ${arrV} = []`,
     `${ind(ctx)}let ${curV} = ${pos}`,
     ...rec ? [`${ind(ctx)}const ${mySyncV} = _ctx._sync`] : [],
     ...firstStmts
   ];
-  const failItem = (nextOkVar, itemPosVar, breakStmt) => {
-    if (!rec) return [`${ind(ctx)}if (!${nextOkVar}) ${breakStmt === "break" ? "break" : `{ ${breakStmt} }`}`];
+  const failItem = (nextOkVar, nextMayCommit, itemPosVar, breakStmt) => {
+    const commit = nextMayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : "";
+    if (!rec) return [`${ind(ctx)}if (!${nextOkVar}) { ${commit}${breakStmt} }`];
     const rr = v(ctx, "_rr");
     return [
       `${ind(ctx)}if (!${nextOkVar}) {`,
+      ...nextMayCommit ? [`${ind(ctx)}  if (_ctx._fc) ${committedFailBody(ctx)}`] : [],
       `${ind(ctx)}  if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${itemPosVar}, _ctx)) {`,
       `${ind(ctx)}    const ${rr} = _ctx._rec.scan(input, ${itemPosVar}, _ctx, ${scanSync}, ${exp})`,
       `${ind(ctx)}    ${arrV}.push(${rr}.error); _ctx._rec.capture(_ctx, ${rr}.error); ${curV} = ${rr}.end; continue`,
@@ -7549,6 +8125,7 @@ function emitSepBy(_p, def, ctx, pos) {
     stmts.push(
       `${ind(ctx)}let ${didV} = false`,
       `${ind(ctx)}if (${firstOk}) { ${arrV}.push(${firstVal}); ${curV} = ${firstEnd}; ${didV} = true }`,
+      ...first.mayCommit ? [`${ind(ctx)}else if (_ctx._fc) ${committedFailBody(ctx)}`] : [],
       `${ind(ctx)}else if (_ctx._tolerant && ${mySyncV} !== undefined && !_ctx._rec.at(${mySyncV}, input, ${pos}, _ctx)) {`,
       `${ind(ctx)}  const ${rr0} = _ctx._rec.scan(input, ${pos}, _ctx, ${scanSync}, ${exp})`,
       `${ind(ctx)}  ${arrV}.push(${rr0}.error); _ctx._rec.capture(_ctx, ${rr0}.error); ${curV} = ${rr0}.end; ${didV} = true`,
@@ -7559,6 +8136,7 @@ function emitSepBy(_p, def, ctx, pos) {
     stmts.push(`${ind(ctx)}while (${curV} < input.length) {`);
     ctx.indent++;
   } else {
+    if (first.mayCommit) stmts.push(`${ind(ctx)}if (!${firstOk} && _ctx._fc) ${committedFailBody(ctx)}`);
     stmts.push(`${ind(ctx)}if (${firstOk}) {`);
     ctx.indent++;
     stmts.push(
@@ -7587,16 +8165,18 @@ function emitSepBy(_p, def, ctx, pos) {
       );
       sepAtPos = spV;
       const rollbackToSep = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; `;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
+      const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const post = postSepMarks();
       stmts.push(...post.decl);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
+      const next = emitFallible(def.parser, ctx, npV, true);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, itemFailBreak(sepEnd, rollbackToSep, post.rb)),
+        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, rollbackToSep, post.rb)),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -7605,14 +8185,16 @@ function emitSepBy(_p, def, ctx, pos) {
       const spV = v(ctx, "_sp");
       stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
       sepAtPos = spV;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+      const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
+      const next = emitFallible(def.parser, ctx, npV, true);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, itemFailBreak(sepEnd, "", "")),
+        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, "", "")),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -7626,15 +8208,17 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`
       );
     }
-    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+    const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
     const nextRb = markLv ? `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markRw}) _ctx._cstRawChildren.length = ${markRw}; ` : "";
     const post = postSepMarks();
     stmts.push(...post.decl);
-    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
+    const next = emitFallible(def.parser, ctx, sepEnd, true);
+    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
     stmts.push(
       ...nextStmts,
-      ...failItem(nextOk, sepEnd, itemFailBreak(sepEnd, nextRb, post.rb)),
+      ...failItem(nextOk, next.mayCommit, sepEnd, itemFailBreak(sepEnd, nextRb, post.rb)),
       `${ind(ctx)}${arrV}.push(${nextVal})`,
       `${ind(ctx)}${curV} = ${nextEnd}`
     );
@@ -7735,6 +8319,18 @@ function emitPeek(def, ctx, pos) {
     endVar: pos
   };
 }
+function emitRouted(ctx, pos) {
+  const item = v(ctx, "_rt");
+  return {
+    stmts: [
+      `${ind(ctx)}const ${item} = _ctx._routed`,
+      ...emitIfFail(ctx, `${item} === undefined || ${item}.span.start !== ${pos}`, failBody(ctx, '"routed()"', pos)),
+      ...emitLeafCapture(ctx, `${item}.value`, `${item}.span.start`, `${item}.span.end`)
+    ],
+    valueVar: `${item}.value`,
+    endVar: `${item}.span.end`
+  };
+}
 function escapeTokenLiteral(value) {
   return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
@@ -8015,7 +8611,7 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   const rv = v(ctx, "_rt");
   const vv = v(ctx, "_rtv");
   const ev = v(ctx, "_rte");
-  const failStmt = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span }`;
+  const failStmt = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${rv}.span.start; _ctx._fx = ${rv}.expected; _ctx._fc = ${rv}.committed === true; break ${ctx.failLabel} }` : `{ _ctx._fc = ${rv}.committed === true; break ${ctx.failLabel} }` : `return { ok: false, expected: ${rv}.expected, span: ${rv}.span, ...(${rv}.committed ? { committed: true } : {}) }`;
   const stmts = [
     `${ind(ctx)}const ${rv} = _rp[${idx}].parse(input, ${pos}, _ctx)`,
     ...emitIfFail(ctx, `!${rv}.ok`, failStmt),
@@ -8096,7 +8692,7 @@ function emitRecover(def, ctx, pos) {
   return { stmts, valueVar: valVar, endVar };
 }
 function emitExpect(def, ctx, pos) {
-  const { stmts: innerStmts, okVar, valVar, endVar } = emitFallible(def.parser, ctx, pos);
+  const { stmts: innerStmts, okVar, valVar, endVar, mayCommit } = emitFallible(def.parser, ctx, pos);
   const ind0 = ind(ctx);
   const errV = v(ctx, "_err");
   const stmts = [
@@ -8108,6 +8704,7 @@ function emitExpect(def, ctx, pos) {
     // interpreter (expect.ts) and the list-recovery emit sites — guarded on
     // `_ctx._tolerant`, under which the driver always installs `_ctx._rec`.
     `${ind0}  if (_ctx._tolerant) _ctx._rec.capture(_ctx, ${errV})`,
+    ...mayCommit ? [`${ind0}  _ctx._fc = false`] : [],
     `${ind0}  ${valVar} = ${errV}`,
     `${ind0}  ${endVar} = ${pos}`,
     `${ind0}  ${okVar} = true`,
@@ -8118,7 +8715,7 @@ function emitExpect(def, ctx, pos) {
 function emit(p, ctx, pos) {
   const replay = ctx.replayPrefix?.get(p);
   if (replay !== void 0) return emitReplayPrefixLeaf(ctx, pos, replay);
-  const dispatch = (emissionPos = pos) => {
+  const dispatch2 = (emissionPos = pos) => {
     const savedRule = ctx.activeCoverageRuleId;
     const rule = ctx.coverage?.plan.rules.get(p);
     if (rule && p !== ctx.coverage?.entry && !ctx.suppressCoverageFailure) ctx.activeCoverageRuleId = rule;
@@ -8158,14 +8755,14 @@ function emit(p, ctx, pos) {
     ctx.indent = 1;
     ctx.failLabel = "_pfail";
     ctx.recordFail = true;
-    const r = dispatch("_pos");
+    const r = dispatch2("_pos");
     ctx.indent = savedIndent;
     ctx.failLabel = savedFailLabel;
     ctx.recordFail = savedRecord;
     pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar);
     return instrument(emitNamedFnCall(ctx, fnName, pos));
   }
-  return instrument(dispatch());
+  return instrument(dispatch2());
 }
 function emitDispatch(p, ctx, pos) {
   const bal = p._balancedAmbient;
@@ -8198,6 +8795,8 @@ function emitDispatch(p, ctx, pos) {
       return emitSeq(def, ctx, pos);
     case "choice":
       return emitChoice(p, def, ctx, pos);
+    case "dispatch":
+      return emitDispatchCombinator(p, def, ctx, pos);
     case "attempt":
       return emitAttempt(p, def, ctx, pos);
     case "many":
@@ -8322,6 +8921,8 @@ function emitDispatch(p, ctx, pos) {
       return emitNot(def, ctx, pos);
     case "peek":
       return emitPeek(def, ctx, pos);
+    case "routed":
+      return emitRouted(ctx, pos);
     case "node":
       return emitNode(def, ctx, pos);
     case "scanTo":
@@ -8418,6 +9019,8 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
     case "sequence":
     case "choice":
       return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "dispatch":
+      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
     case "sepBy":
       return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
     case "scanTo":
@@ -8432,6 +9035,26 @@ function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
   }
 }
+function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "routed":
+      return true;
+    case "lazy": {
+      try {
+        return parserUsesRouted2(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "dispatch":
+      return false;
+    default:
+      return childrenOf2(d).some((child) => parserUsesRouted2(child, seen));
+  }
+}
 function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
   seen.add(p);
@@ -8451,6 +9074,8 @@ function childrenOf2(def) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.matchers ? def.matchers.map((entry) => entry.parser) : [], ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "attempt":
     case "optional":
@@ -8487,6 +9112,7 @@ function childrenOf2(def) {
     case "regex":
     case "keywords":
     case "guard":
+    case "routed":
     case "unknown":
       return [];
   }
@@ -8494,6 +9120,7 @@ function childrenOf2(def) {
 var HOISTABLE_TAGS = /* @__PURE__ */ new Set([
   "sequence",
   "choice",
+  "dispatch",
   "many",
   "oneOrMore",
   "optional",
@@ -9318,6 +9945,8 @@ function childrenOf3(def) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.matchers ? def.matchers.map((entry) => entry.parser) : [], ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "oneOrMore":
     case "optional":
@@ -9346,6 +9975,7 @@ function childrenOf3(def) {
     case "literal":
     case "regex":
     case "keywords":
+    case "routed":
     case "guard":
     case "recover":
     case "unknown":
@@ -9370,6 +10000,16 @@ function repeatOpts(min, max, trailing) {
   if (trailing !== void 0) parts.push(`trailing: ${JSON.stringify(trailing)}`);
   return parts.length === 0 ? "" : `, { ${parts.join(", ")} }`;
 }
+function matcherExpr(entry) {
+  switch (entry.kind) {
+    case "startsWith":
+      return `startsWith(${JSON.stringify(entry.value)})`;
+    case "endsWith":
+      return `endsWith(${JSON.stringify(entry.value)})`;
+    case "matches":
+      return `matches(${new RegExp(entry.value, entry.flags ?? "").toString()})`;
+  }
+}
 function serializeRuleMap(ruleMap, scanSkip) {
   try {
     return new Serializer(ruleMap, scanSkip ?? []).run();
@@ -9467,6 +10107,13 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "startsWith",
+    "endsWith",
+    "matches",
+    "otherwise",
+    "routed",
     "attempt",
     "many",
     "oneOrMore",
@@ -9500,6 +10147,13 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    startsWith,
+    endsWith,
+    matches,
+    otherwise,
+    routed,
     attempt,
     many,
     oneOrMore,
@@ -9685,6 +10339,18 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         });
         return `_gch([${items.join(", ")}])`;
       }
+      case "dispatch": {
+        const arms = def.cases.map(
+          (entry) => `when(${entry.keys.length === 1 ? JSON.stringify(entry.keys[0]) : JSON.stringify(entry.keys)}, ${kid(entry.parser)}${entry.caseInsensitive ? ", { caseInsensitive: true }" : ""})`
+        );
+        if (def.matchers) {
+          for (const entry of def.matchers) {
+            arms.push(`when(${matcherExpr(entry)}, ${kid(entry.parser)}${entry.caseInsensitive ? ", { caseInsensitive: true }" : ""})`);
+          }
+        }
+        if (def.otherwise) arms.push(`otherwise(${kid(def.otherwise)})`);
+        return `dispatch(${kid(def.selector)}${arms.length === 0 ? "" : `, ${arms.join(", ")}`})`;
+      }
       case "many":
         return `many(${kid(def.parser)}${repeatOpts(def.min, def.max)})`;
       // A `oneOrMore` def with min > 1 came from `many(x, { min: n })`; round-trip
@@ -9701,6 +10367,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         return `not(${kid(def.parser)})`;
       case "peek":
         return `peek(${kid(def.parser)})`;
+      case "routed":
+        return "routed()";
       case "trivia":
         return `trivia(${kid(def.parser)})`;
       case "token":
@@ -10170,6 +10838,12 @@ function stripTsFromSource(node2, code) {
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
 }
+function isWhenFactory(v2) {
+  return !!v2 && typeof v2 === "object" && v2.tag === "whenFactory";
+}
+function isStaticValueEntry(v2) {
+  return !!v2 && typeof v2 === "object" && "value" in v2 && "mfSrcs" in v2;
+}
 function wordFactoryFromArgs(args, scope, code, mfs) {
   const [boundaryOrOptsArg, optsArg] = args;
   if (boundaryOrOptsArg?.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
@@ -10189,6 +10863,23 @@ function wordFactoryFromArgs(args, scope, code, mfs) {
   if (typeof caseInsensitive !== "boolean") return null;
   return { tag: "wordFactory", boundary: "_0-9A-Za-z", caseInsensitive };
 }
+function dispatchWhenOptions(v2) {
+  if (v2 === void 0) return {};
+  if (typeof v2 !== "object" || v2 === null || Array.isArray(v2)) return null;
+  for (const key of Object.keys(v2)) {
+    if (key !== "caseInsensitive") return null;
+  }
+  const caseInsensitive = "caseInsensitive" in v2 ? v2.caseInsensitive : false;
+  if (typeof caseInsensitive !== "boolean") return null;
+  return { caseInsensitive };
+}
+function whenFactoryFromArgs(args, scope, code, mfs) {
+  const [optsArg, extra] = args;
+  if (optsArg?.type === "SpreadElement" || extra !== void 0) return null;
+  const rawOpts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs);
+  const opts = dispatchWhenOptions(rawOpts);
+  return opts === null ? null : { tag: "whenFactory", caseInsensitive: opts.caseInsensitive ?? false };
+}
 var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
   regex: (...a) => regex(a[0], a[1]),
@@ -10204,6 +10895,7 @@ var SUPPORTED = {
   field: (...a) => field(a[0], a[1]),
   noTrivia: (...a) => noTrivia(a[0]),
   token: (...a) => token(a[0]),
+  routed: () => routed(),
   leaf: (...a) => leaf(a[0], a[1]),
   expect: (...a) => expect(a[0], a[1])
 };
@@ -10239,9 +10931,65 @@ function gatedArmParts(e) {
   }
   return gate2 && combinator ? { gate: gate2, combinator } : null;
 }
+function dispatchArmValue(node2, scope, code, mfs) {
+  if (node2.type === "Identifier") {
+    const value = anyValue(node2, scope, code, mfs);
+    return isDispatchArm(value) ? value : null;
+  }
+  if (node2.type !== "CallExpression") return null;
+  const callee = node2.callee;
+  if (callee.type !== "Identifier") return null;
+  const factory = scope.get(callee.name);
+  if (isWhenFactory(factory)) {
+    const [keyArg, parserArg, extraArg] = node2.arguments;
+    if (!keyArg || !parserArg || extraArg !== void 0 || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
+    const key = anyValue(keyArg, scope, code, mfs);
+    const parserValue = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(parserValue)) return null;
+    const opts = { caseInsensitive: factory.caseInsensitive };
+    if (typeof key === "string") return when(key, parserValue, opts);
+    if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
+    return null;
+  }
+  if (callee.name === "otherwise") {
+    const [parserArg] = node2.arguments;
+    if (!parserArg || parserArg.type === "SpreadElement") return null;
+    const parserValue = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(parserValue)) return null;
+    return otherwise(parserValue);
+  }
+  if (callee.name === "when") {
+    const [keyArg, parserArg, optsArg] = node2.arguments;
+    if (!keyArg || !parserArg || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
+    const key = anyValue(keyArg, scope, code, mfs);
+    const parserValue = anyValue(parserArg, scope, code, mfs);
+    const opts = dispatchWhenOptions(optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs));
+    if (opts === null) return null;
+    if (!isCombinator(parserValue)) return null;
+    if (typeof key === "string") return when(key, parserValue, opts);
+    if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue, opts);
+    if (isDispatchMatcher(key)) return when(key, parserValue, opts);
+  }
+  return null;
+}
 function isCombinator(v2) {
   return !!v2 && typeof v2 === "object" && "_def" in v2;
 }
+function isDispatchArm(v2) {
+  if (!v2 || typeof v2 !== "object") return false;
+  const rec = v2;
+  if (rec.kind === "otherwise") return isCombinator(rec.parser);
+  if (rec.kind === "whenMatcher") {
+    return isDispatchMatcher(rec.matcher) && typeof rec.caseInsensitive === "boolean" && isCombinator(rec.parser);
+  }
+  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && typeof rec.caseInsensitive === "boolean" && isCombinator(rec.parser);
+}
+function isDispatchMatcher(v2) {
+  if (!v2 || typeof v2 !== "object") return false;
+  const rec = v2;
+  if ((rec.kind === "startsWith" || rec.kind === "endsWith") && typeof rec.value === "string") return true;
+  return rec.kind === "matches" && typeof rec.value === "string" && typeof rec.flags === "string";
+}
 function scopeGet(scope, name, mfs) {
   const entry = scope.get(name);
   if (!entry) return null;
@@ -10498,6 +11246,25 @@ function exprToCombi(node2, scope, code, mfs) {
       return null;
     }
   }
+  if (callee.name === "dispatch") {
+    const [selectorArg, ...armArgs] = node2.arguments;
+    if (!selectorArg || selectorArg.type === "SpreadElement") return null;
+    const selector = anyValue(selectorArg, scope, code, mfs);
+    if (!isCombinator(selector)) return null;
+    const arms = [];
+    for (const arg of armArgs) {
+      if (arg.type === "SpreadElement") return null;
+      const arm = dispatchArmValue(arg, scope, code, mfs);
+      if (!isDispatchArm(arm)) return null;
+      arms.push(arm);
+    }
+    try {
+      const unsafeDispatch = dispatch;
+      return unsafeDispatch(selector, ...arms);
+    } catch {
+      return null;
+    }
+  }
   if (callee.name === "choice" && node2.arguments.some((a) => a.type !== "SpreadElement" && isGatedArmExpr(a))) {
     if (code === void 0 || mfs === void 0) return null;
     const arms = [];
@@ -10583,6 +11350,10 @@ function anyValue(node2, scope, code, mfs) {
       if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
       return entry.combi;
     }
+    if (isStaticValueEntry(entry)) {
+      if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
+      return entry.value;
+    }
     return entry;
   }
   if (node2.type === "MemberExpression") {
@@ -10603,6 +11374,27 @@ function anyValue(node2, scope, code, mfs) {
     if (callee.type === "Identifier" && callee.name === "makeWord") {
       return wordFactoryFromArgs(node2.arguments, scope, code, mfs);
     }
+    if (callee.type === "Identifier" && callee.name === "makeWhen") {
+      return whenFactoryFromArgs(node2.arguments, scope, code, mfs);
+    }
+    if (callee.type === "Identifier" && (callee.name === "startsWith" || callee.name === "endsWith")) {
+      if (node2.arguments.length !== 1 || node2.arguments[0]?.type === "SpreadElement") return null;
+      const value = anyValue(node2.arguments[0], scope, code, mfs);
+      if (typeof value !== "string") return null;
+      return callee.name === "startsWith" ? startsWith(value) : endsWith(value);
+    }
+    if (callee.type === "Identifier" && callee.name === "matches") {
+      if (node2.arguments.length !== 1 || node2.arguments[0]?.type === "SpreadElement") return null;
+      const value = anyValue(node2.arguments[0], scope, code, mfs);
+      if (!(value instanceof RegExp)) return null;
+      return matches(value);
+    }
+    if (callee.type === "Identifier" && (callee.name === "when" || callee.name === "otherwise")) {
+      return dispatchArmValue(node2, scope, code, mfs);
+    }
+    if (callee.type === "Identifier" && isWhenFactory(scope.get(callee.name))) {
+      return dispatchArmValue(node2, scope, code, mfs);
+    }
     return exprToCombi(node2, scope, code, mfs);
   }
   return null;
@@ -10613,6 +11405,12 @@ function evaluateWordFactory(node2, scope, code) {
   if (callee.type !== "Identifier" || callee.name !== "makeWord") return null;
   return wordFactoryFromArgs(node2.arguments, scope, code);
 }
+function evaluateWhenFactory(node2, scope, code) {
+  if (node2.type !== "CallExpression") return null;
+  const callee = node2.callee;
+  if (callee.type !== "Identifier" || callee.name !== "makeWhen") return null;
+  return whenFactoryFromArgs(node2.arguments, scope, code);
+}
 function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
 }
@@ -10661,6 +11459,7 @@ function evalBodyStatements(statements, scope, code) {
       if (val === null) return false;
       const thisDeclMfSrcs = bodyMfs.slice(before);
       if (isCombinator(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
       else scope.set(name, val);
     }
   }
@@ -11192,7 +11991,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     for (const match of source.matchAll(/id:\s*"([^"]+)"/g)) ids.add(match[1]);
     return [...ids].sort().map((id2) => ({
       id: id2,
-      kind: id2.startsWith("rule:") ? "rule" : id2.startsWith("label:") ? "label" : "choice-arm"
+      kind: id2.startsWith("rule:") ? "rule" : id2.startsWith("label:") ? "label" : id2.startsWith("dispatch:") ? "dispatch-arm" : "choice-arm"
     }));
   };
   const localComposedCarried = /* @__PURE__ */ new Map();
@@ -11638,6 +12437,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           if (wordFactory) {
             ;
             scope.set(varName, wordFactory);
+            replacements.push({ start: init.start, end: init.end, replacement: "undefined" });
+            continue;
+          }
+          const whenFactory = evaluateWhenFactory(init, scope, code);
+          if (whenFactory) {
+            ;
+            scope.set(varName, whenFactory);
+            replacements.push({ start: init.start, end: init.end, replacement: "undefined" });
             continue;
           }
           const combiArray = evaluateCombinatorArray(init, scope, code);