parseman 0.38.0 → 0.39.1

package/dist/index.cjs

@@ -55,7 +55,9 @@ __export(index_exports, {
   createGrammarTraceSink: () => createGrammarTraceSink,
   createVisitor: () => createVisitor,
   cstBuildHost: () => cstBuildHost,
+  dispatch: () => dispatch,
   duplicationFindingCount: () => duplicationFindingCount,
+  endsWith: () => endsWith,
   expect: () => expect,
   extractCharClasses: () => extractCharClasses,
   field: () => field,
@@ -78,8 +80,10 @@ __export(index_exports, {
   lineBreaksIn: () => lineBreaksIn,
   lineStartWithin: () => lineStartWithin,
   literal: () => literal,
+  makeWhen: () => makeWhen,
   makeWord: () => makeWord,
   many: () => many,
+  matches: () => matches,
   noTrivia: () => noTrivia,
   node: () => node,
   not: () => not,
@@ -87,6 +91,7 @@ __export(index_exports, {
   oneOrMore: () => oneOrMore,
   oneOrMoreSep: () => oneOrMoreSep,
   optional: () => optional,
+  otherwise: () => otherwise,
   parse: () => parse,
   parseDoc: () => parseDoc,
   parser: () => parser,
@@ -95,6 +100,7 @@ __export(index_exports, {
   regex: () => regex,
   relativize: () => relativize,
   relativizeCST: () => relativizeCST,
+  routed: () => routed,
   rules: () => rules,
   run: () => run,
   runWithGrammarCoverage: () => runWithGrammarCoverage,
@@ -104,12 +110,14 @@ __export(index_exports, {
   shiftAbsolute: () => shiftAbsolute,
   siteToString: () => siteToString,
   skip: () => skip,
+  startsWith: () => startsWith,
   token: () => token,
   transform: () => transform,
   trivia: () => trivia,
   triviaEntries: () => triviaEntries,
   triviaKindMask: () => triviaKindMask,
   walk: () => walk,
+  when: () => when,
   withCtx: () => withCtx,
   word: () => word
 });
@@ -168,6 +176,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
       return d.value.length === 0;
     case "keywords":
       return false;
+    case "routed":
+      return false;
     case "regex":
       try {
         const m = new RegExp(d.source).exec("");
@@ -194,6 +204,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
       return d.parsers.every(me);
     case "choice":
       return d.parsers.some(me);
+    case "dispatch":
+      return me(d.selector);
     case "transform":
     case "label":
     case "trivia":
@@ -267,6 +279,8 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
     case "keywords":
       return p._meta.firstSet;
     // terminals: no refs, cached set is exact
+    case "dispatch":
+      return fs(d.selector);
     case "lazy":
       try {
         return fs(d.thunk());
@@ -1184,6 +1198,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
@@ -1223,6 +1239,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] : [];
@@ -1325,6 +1343,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 {
@@ -1365,6 +1384,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];
@@ -2044,6 +2064,248 @@ 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 makeWhen(opts = {}) {
+  return (key, parser2) => when(key, parser2, opts);
+}
+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);
@@ -2066,6 +2328,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 } };
     }
   };
@@ -2095,6 +2358,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) {
@@ -2138,6 +2402,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;
@@ -2182,6 +2447,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 } };
         }
@@ -2194,6 +2460,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;
@@ -2232,6 +2499,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 } };
     }
   };
@@ -2271,6 +2539,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);
@@ -2298,6 +2567,7 @@ function sepBy(combinator, separator, opts = {}) {
         const sep = separator.parse(input, sepPos, ctx);
         if (!sep.ok) {
           rollbackTrivia(ctx, loopMark);
+          if (sep.committed) return sep;
           break;
         }
         const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
@@ -2313,6 +2583,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);
@@ -2405,6 +2676,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;
@@ -2680,6 +2957,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":
@@ -2747,6 +3026,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": {
@@ -2772,6 +3053,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":
@@ -3173,7 +3456,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");
@@ -3329,6 +3612,8 @@ function classifyBroadArm(arm, resolve) {
         }
         return null;
       }
+      case "dispatch":
+        return walk2(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
@@ -3428,6 +3713,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 {
@@ -3534,6 +3825,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":
@@ -3590,6 +3887,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":
@@ -3661,6 +3960,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":
@@ -3684,6 +3988,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":
@@ -4932,11 +5240,25 @@ function escapeClassChar(ch2) {
 }
 
 // src/compiler/grammar-coverage-ids.ts
+function idPart(value) {
+  return encodeURIComponent(value);
+}
+function dispatchArmIds(def, path) {
+  const ids = [];
+  for (const entry of def.cases) ids.push(`dispatch:${path}/when:${entry.keys.map(idPart).join("|")}`);
+  for (const entry of def.matchers ?? []) {
+    ids.push(`dispatch:${path}/matcher:${entry.kind}:${idPart(entry.value)}${entry.kind === "matches" && entry.flags ? `:${idPart(entry.flags)}` : ""}`);
+  }
+  if (def.otherwise) ids.push(`dispatch:${path}/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":
@@ -4979,6 +5301,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();
@@ -5009,6 +5332,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, path);
+      dispatches.set(parser2, ids);
+      ids.forEach((id) => definitions.set(id, { id, kind: "dispatch-arm" }));
+    }
     if (parser2._def.tag === "attempt") attempts.set(parser2, `attempt:${path}`);
     if (parser2._def.tag === "label") {
       const id = `label:${path}`;
@@ -5021,7 +5349,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
@@ -6395,12 +6723,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) {
@@ -6475,6 +6806,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) {
@@ -6511,15 +6845,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();
@@ -6732,6 +7073,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.
@@ -6776,6 +7119,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);
@@ -6786,6 +7173,7 @@ function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
     case "keywords":
     case "node":
     case "token":
+    case "routed":
     case "leaf":
       return true;
     case "not":
@@ -6797,6 +7185,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":
@@ -6843,6 +7233,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;
@@ -6856,6 +7247,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`,
@@ -6864,7 +7256,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) {
@@ -7241,6 +7633,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);
@@ -7362,12 +7934,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}) {`);
@@ -7382,7 +7958,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");
@@ -7406,10 +7984,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} }`);
@@ -7566,7 +8146,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");
@@ -7585,7 +8166,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}++`);
@@ -7597,10 +8179,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}`
   ];
@@ -7632,7 +8216,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
@@ -7646,18 +8230,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`,
@@ -7686,6 +8273,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`,
@@ -7696,6 +8284,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(
@@ -7724,16 +8313,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep.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}`
       );
@@ -7742,14 +8333,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep.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}`
       );
@@ -7763,15 +8356,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 sep = emitFallible(def.separator, ctx, sepAtPos, true);
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep;
+    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep.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}`
     );
@@ -7872,6 +8467,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, "\\$&");
 }
@@ -8152,7 +8759,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),
@@ -8233,7 +8840,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 = [
@@ -8245,6 +8852,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`,
@@ -8255,7 +8863,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;
@@ -8295,14 +8903,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;
@@ -8335,6 +8943,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":
@@ -8459,6 +9069,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":
@@ -8555,6 +9167,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":
@@ -8569,6 +9183,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);
@@ -8588,6 +9222,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":
@@ -8624,6 +9260,7 @@ function childrenOf2(def) {
     case "regex":
     case "keywords":
     case "guard":
+    case "routed":
     case "unknown":
       return [];
   }
@@ -8631,6 +9268,7 @@ function childrenOf2(def) {
 var HOISTABLE_TAGS = /* @__PURE__ */ new Set([
   "sequence",
   "choice",
+  "dispatch",
   "many",
   "oneOrMore",
   "optional",
@@ -9329,6 +9967,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":
@@ -9357,6 +9997,7 @@ function childrenOf3(def) {
     case "literal":
     case "regex":
     case "keywords":
+    case "routed":
     case "guard":
     case "recover":
     case "unknown":
@@ -9381,6 +10022,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();
@@ -9478,6 +10129,13 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "startsWith",
+    "endsWith",
+    "matches",
+    "otherwise",
+    "routed",
     "attempt",
     "many",
     "oneOrMore",
@@ -9511,6 +10169,13 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    startsWith,
+    endsWith,
+    matches,
+    otherwise,
+    routed,
     attempt,
     many,
     oneOrMore,
@@ -9696,6 +10361,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
@@ -9712,6 +10389,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":
@@ -10733,10 +11412,20 @@ function run(entry, input, options = {}) {
 }
 
 // src/coverage.ts
+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));
+  }
+}
 var GRAMMAR_COVERAGE_DEFINITIONS = /* @__PURE__ */ Symbol.for("parseman.grammarCoverageDefinitions");
 function compiledGrammarCoverageDefinitions(grammar) {
   const definitions = grammar[GRAMMAR_COVERAGE_DEFINITIONS];
-  if (!Array.isArray(definitions) || !definitions.every((definition) => typeof definition === "object" && definition !== null && typeof definition.id === "string" && (definition.kind === "rule" || definition.kind === "choice-arm" || definition.kind === "label"))) {
+  if (!Array.isArray(definitions) || !definitions.every((definition) => typeof definition === "object" && definition !== null && typeof definition.id === "string" && (definition.kind === "rule" || definition.kind === "choice-arm" || definition.kind === "dispatch-arm" || definition.kind === "label"))) {
     throw new TypeError("grammar has no coverage definitions; enable grammarCoverage for this macro build");
   }
   return definitions;
@@ -10915,6 +11604,56 @@ function coverageEntry(entry, collector, maps, trace) {
           const unsafeSequence = sequence;
           return unsafeSequence(...def.parsers.map(build));
         }
+        case "dispatch": {
+          const ids = maps.dispatches.get(parser2) ?? [];
+          let armIndex = 0;
+          const dispatchStarts = [];
+          const wrapArm = (arm, id) => {
+            const child = build(arm);
+            return {
+              _tag: child._tag,
+              _meta: child._meta,
+              _def: child._def,
+              parse(input, pos, ctx) {
+                const dispatchStart = dispatchStarts[dispatchStarts.length - 1] ?? pos;
+                if (id) trace?.write({ id, phase: "attempt", offset: dispatchStart });
+                const result = child.parse(input, pos, ctx);
+                if (result.ok) {
+                  if (id) {
+                    collector.hit(id);
+                    trace?.write({ id, phase: "selected", offset: dispatchStart, end: result.span.end });
+                    trace?.write({ id, phase: "success", offset: dispatchStart, end: result.span.end });
+                  }
+                } else if (id) {
+                  trace?.write({ id, phase: "failure", offset: result.span.end });
+                }
+                return result;
+              }
+            };
+          };
+          const arms = def.cases.map(
+            (entry2) => when(entry2.keys, wrapArm(entry2.parser, ids[armIndex++]), entry2.caseInsensitive ? { caseInsensitive: true } : void 0)
+          );
+          if (def.matchers) {
+            for (const entry2 of def.matchers) {
+              arms.push(when(dispatchMatcher(entry2), wrapArm(entry2.parser, ids[armIndex++]), entry2.caseInsensitive ? { caseInsensitive: true } : void 0));
+            }
+          }
+          if (def.otherwise) arms.push(otherwise(wrapArm(def.otherwise, ids[armIndex++])));
+          const unsafeDispatch = dispatch;
+          const base2 = unsafeDispatch(build(def.selector), ...arms);
+          return {
+            ...base2,
+            parse(input, pos, ctx) {
+              dispatchStarts.push(pos);
+              try {
+                return base2.parse(input, pos, ctx);
+              } finally {
+                dispatchStarts.pop();
+              }
+            }
+          };
+        }
         case "many":
           return many(build(def.parser));
         case "oneOrMore":