parseman 0.38.0 → 0.39.0

package/dist/index.js

@@ -77,6 +77,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":
@@ -150,6 +152,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());
@@ -1067,6 +1071,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
@@ -1208,6 +1214,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 {
@@ -1248,6 +1255,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];
@@ -1927,6 +1935,75 @@ function sequence(...parsers) {
   };
 }
 
+// src/combinators/dispatch.ts
+function when(key, parser2) {
+  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 };
+}
+function otherwise(parser2) {
+  return { kind: "otherwise", parser: parser2 };
+}
+function dispatch(selector, ...arms) {
+  let fallback;
+  const cases = [];
+  const seen = /* @__PURE__ */ new Set();
+  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;
+      continue;
+    }
+    for (const key of arm.keys) {
+      if (seen.has(key)) throw new Error(`parseman: duplicate dispatch key ${JSON.stringify(key)}`);
+      seen.add(key);
+    }
+    cases.push({ keys: arm.keys, parser: arm.parser });
+  }
+  const meta = {
+    firstSet: selector._meta.firstSet,
+    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || (fallback?._meta.canMatchNewline ?? false),
+    isTrivia: false
+  };
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of cases) for (const key of entry.keys) byKey.set(key, entry.parser);
+  return {
+    _tag: "dispatch",
+    _meta: meta,
+    _def: {
+      tag: "dispatch",
+      selector,
+      cases,
+      ...fallback === void 0 ? {} : { otherwise: fallback }
+    },
+    parse(input, pos, ctx) {
+      const selected = selector.parse(input, pos, ctx);
+      if (!selected.ok) return selected;
+      const tail = byKey.get(selected.value) ?? fallback;
+      if (tail === 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 mark = saveTriviaMark(ctx);
+      const result = tail.parse(input, selected.span.end, ctx);
+      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);
@@ -1949,6 +2026,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 } };
     }
   };
@@ -1978,6 +2056,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) {
@@ -2021,6 +2100,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;
@@ -2065,6 +2145,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 } };
         }
@@ -2077,6 +2158,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;
@@ -2115,6 +2197,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 } };
     }
   };
@@ -2154,6 +2237,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);
@@ -2181,6 +2265,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);
@@ -2196,6 +2281,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);
@@ -2288,6 +2374,11 @@ 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.otherwise) visit(def.otherwise, consumed);
+        return;
       case "node":
         visit(def.parser, false);
         return;
@@ -2563,6 +2654,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.otherwise ? parserHasOwnFields(d.otherwise, seen) : false);
     case "sepBy":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.separator, seen);
     case "skip":
@@ -2630,6 +2723,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.otherwise ? parserHasTriviaSite(d.otherwise, seen) : false);
     case "grammar":
       return parserHasTriviaSite(d.parser, seen);
     case "lazy": {
@@ -2655,6 +2750,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.otherwise ? parserEnablesTriviaCapture(d.otherwise, seen) : false);
     case "sepBy":
       return parserEnablesTriviaCapture(d.parser, seen) || parserEnablesTriviaCapture(d.separator, seen);
     case "skip":
@@ -3056,7 +3153,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.38.0";
+var PARSEMAN_VERSION = "0.39.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3212,6 +3309,8 @@ function classifyBroadArm(arm, resolve) {
         }
         return null;
       }
+      case "dispatch":
+        return walk2(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
@@ -3311,6 +3410,11 @@ 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.otherwise !== void 0) kids.push(d.otherwise);
+    }
     if (Array.isArray(rec.skip)) kids.push(...rec.skip);
     if (d.tag === "lazy") {
       try {
@@ -3417,6 +3521,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":
@@ -3473,6 +3583,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":
@@ -3544,6 +3656,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":
@@ -3567,6 +3684,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":
@@ -4820,6 +4941,8 @@ function children(def, winners) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "oneOrMore":
     case "optional":
@@ -6284,6 +6407,8 @@ function leadingFirstSetRecipe(p, seen = /* @__PURE__ */ new Set()) {
         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) {
@@ -6358,6 +6483,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) {
@@ -6394,15 +6522,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();
@@ -6615,6 +6750,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.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.
@@ -6659,6 +6796,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);
@@ -6680,6 +6861,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.otherwise ? capturesLeaf(d.otherwise, seen) : false);
     case "sepBy":
       return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
     case "many":
@@ -6726,6 +6909,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;
@@ -6739,6 +6923,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`,
@@ -6747,7 +6932,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) {
@@ -7124,6 +7309,118 @@ 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;
+      }
+      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(def, ctx, pos) {
+  const selector = emit(def.selector, ctx, pos);
+  const outV = v(ctx, "_dval");
+  const outE = v(ctx, "_dend");
+  const keyV = v(ctx, "_dkey");
+  const stmts = [
+    ...selector.stmts,
+    `${ind(ctx)}const ${keyV} = ${selector.valueVar}`,
+    `${ind(ctx)}let ${outV}, ${outE} = ${selector.endVar}`
+  ];
+  let wroteBranch = false;
+  const emitSelectedTail = (parser2, keyword, condition) => {
+    const head = keyword === "else" ? `${ind(ctx)}else {` : `${ind(ctx)}${keyword} (${condition}) {`;
+    stmts.push(head);
+    ctx.indent++;
+    const mayError = mayRecordRecoveryError(parser2, !!ctx.recovery);
+    const errMark = mayError ? v(ctx, "_derr") : null;
+    const logMark = ctx.activeTrivia ? v(ctx, "_dlog") : null;
+    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(parser2, ctx, selector.endVar);
+    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}; ` : "";
+    stmts.push(
+      ...tail.stmts,
+      `${ind(ctx)}if (!${tail.okVar}) { ${errorRollback}${logRollback}${committedFailBody(ctx)} }`,
+      `${ind(ctx)}${outV} = [${selector.valueVar}, ${tail.valVar}]`,
+      `${ind(ctx)}${outE} = ${tail.endVar}`
+    );
+    ctx.indent--;
+    stmts.push(`${ind(ctx)}}`);
+  };
+  for (const entry of def.cases) {
+    const condition = entry.keys.map((key) => `${keyV} === ${JSON.stringify(key)}`).join(" || ");
+    emitSelectedTail(entry.parser, wroteBranch ? "else if" : "if", condition);
+    wroteBranch = true;
+  }
+  if (def.otherwise) {
+    if (wroteBranch) emitSelectedTail(def.otherwise, "else");
+    else emitSelectedTail(def.otherwise, "if", "true");
+  } else {
+    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 emitGreedyClassify(def, superIndex, ctx, pos, coverageBase) {
   const superParser = def.parsers[superIndex];
   const regexDef = getCoreRegexDef(superParser);
@@ -7245,12 +7542,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}) {`);
@@ -7265,7 +7566,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");
@@ -7289,10 +7592,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} }`);
@@ -7449,7 +7754,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");
@@ -7468,7 +7774,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}++`);
@@ -7480,10 +7787,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}`
   ];
@@ -7515,7 +7824,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
@@ -7529,18 +7838,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`,
@@ -7569,6 +7881,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`,
@@ -7579,6 +7892,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(
@@ -7607,16 +7921,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}`
       );
@@ -7625,14 +7941,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}`
       );
@@ -7646,15 +7964,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}`
     );
@@ -8035,7 +8355,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),
@@ -8116,7 +8436,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 = [
@@ -8128,6 +8448,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`,
@@ -8138,7 +8459,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;
@@ -8178,14 +8499,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;
@@ -8218,6 +8539,8 @@ function emitDispatch(p, ctx, pos) {
       return emitSeq(def, ctx, pos);
     case "choice":
       return emitChoice(p, def, ctx, pos);
+    case "dispatch":
+      return emitDispatchCombinator(def, ctx, pos);
     case "attempt":
       return emitAttempt(p, def, ctx, pos);
     case "many":
@@ -8438,6 +8761,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.otherwise ? hasNodeDef(d.otherwise, seen) : false);
     case "sepBy":
       return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
     case "scanTo":
@@ -8471,6 +8796,8 @@ function childrenOf2(def) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "attempt":
     case "optional":
@@ -8514,6 +8841,7 @@ function childrenOf2(def) {
 var HOISTABLE_TAGS = /* @__PURE__ */ new Set([
   "sequence",
   "choice",
+  "dispatch",
   "many",
   "oneOrMore",
   "optional",
@@ -9212,6 +9540,8 @@ function childrenOf3(def) {
     case "sequence":
     case "choice":
       return def.parsers;
+    case "dispatch":
+      return [def.selector, ...def.cases.map((entry) => entry.parser), ...def.otherwise ? [def.otherwise] : []];
     case "many":
     case "oneOrMore":
     case "optional":
@@ -9361,6 +9691,9 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "otherwise",
     "attempt",
     "many",
     "oneOrMore",
@@ -9394,6 +9727,9 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    otherwise,
     attempt,
     many,
     oneOrMore,
@@ -9579,6 +9915,13 @@ ${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)})`
+        );
+        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
@@ -10798,6 +11141,12 @@ function coverageEntry(entry, collector, maps, trace) {
           const unsafeSequence = sequence;
           return unsafeSequence(...def.parsers.map(build));
         }
+        case "dispatch": {
+          const arms = def.cases.map((entry2) => when(entry2.keys, build(entry2.parser)));
+          if (def.otherwise) arms.push(otherwise(build(def.otherwise)));
+          const unsafeDispatch = dispatch;
+          return unsafeDispatch(build(def.selector), ...arms);
+        }
         case "many":
           return many(build(def.parser));
         case "oneOrMore":
@@ -11242,6 +11591,7 @@ export {
   createGrammarTraceSink,
   createVisitor,
   cstBuildHost,
+  dispatch,
   duplicationFindingCount,
   expect,
   extractCharClasses,
@@ -11274,6 +11624,7 @@ export {
   oneOrMore,
   oneOrMoreSep,
   optional,
+  otherwise,
   parse,
   parseDoc,
   parser,
@@ -11297,6 +11648,7 @@ export {
   triviaEntries,
   triviaKindMask,
   walk,
+  when,
   withCtx,
   word
 };