parseman 0.37.0 → 0.39.0

package/dist/plugin/index.js

@@ -85,6 +85,8 @@ function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve2) {
       return d.parsers.every(me);
     case "choice":
       return d.parsers.some(me);
+    case "dispatch":
+      return me(d.selector);
     case "transform":
     case "label":
     case "trivia":
@@ -158,6 +160,8 @@ function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve2) {
     case "keywords":
       return p._meta.firstSet;
     // terminals: no refs, cached set is exact
+    case "dispatch":
+      return fs2(d.selector);
     case "lazy":
       try {
         return fs2(d.thunk());
@@ -1106,6 +1110,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
@@ -1244,6 +1250,7 @@ function choice(...args) {
           const result = parsers[idx].parse(input, pos, ctx);
           if (result.ok) return result;
           expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: { start: pos, end: pos }, committed: true };
           return { ok: false, expected, span: { start: pos, end: pos } };
         }
         return {
@@ -1284,6 +1291,7 @@ function choice(...args) {
           rollbackCstCapture(ctx, mark);
           if (logLen !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== logLen) ctx._triviaLog.length = logLen;
           expected.push(...result.expected);
+          if (result.committed) return { ok: false, expected, span: result.span, committed: true };
           continue;
         }
         const checks = autoNot[i];
@@ -1963,6 +1971,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);
@@ -1985,6 +2062,7 @@ function attempt(parser2) {
       if (result.ok) return result;
       rollbackCstCapture(ctx, mark);
       if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (result.committed) return result;
       return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
   };
@@ -2014,6 +2092,7 @@ function repItem(combinator, input, cur, ctx, guardable) {
   const result = combinator.parse(input, pos, ctx);
   if (!result.ok) {
     rollbackTrivia(ctx, mark);
+    if (result.committed) return { fail: result, failPos: pos };
     return { fail: result, failPos: pos };
   }
   if (result.span.end === pos) {
@@ -2057,6 +2136,7 @@ function many(combinator, opts = {}) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -2101,6 +2181,7 @@ function atLeast(combinator, min, max) {
       while (count < min) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop" || "fail" in item) {
+          if (item !== "stop" && !item.fail.ok && item.fail.committed) return item.fail;
           expected ??= deriveExpected(combinator);
           return { ok: false, expected: expected.length > 0 ? expected : [combinator._tag], span: { start: cur, end: cur } };
         }
@@ -2113,6 +2194,7 @@ function atLeast(combinator, min, max) {
         const item = repItem(combinator, input, cur, ctx, guardable);
         if (item === "stop") break;
         if ("fail" in item) {
+          if (!item.fail.ok && item.fail.committed) return item.fail;
           const sync = ctx._tolerant ? ctx._sync : void 0;
           if (sync === void 0) break;
           if (matchesAt(sync, input, item.failPos, ctx)) break;
@@ -2151,6 +2233,7 @@ function optional(combinator) {
       const result = combinator.parse(input, pos, ctx);
       if (result.ok) return result;
       rollbackTrivia(ctx, mark);
+      if (result.committed) return result;
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }
   };
@@ -2190,6 +2273,7 @@ function sepBy(combinator, separator, opts = {}) {
         values.push(first.value);
         cur = first.span.end;
       } else {
+        if (first.committed) return first;
         const term = ctx._tolerant ? ctx._sync : void 0;
         if (term === void 0 || matchesAt(term, input, pos, ctx)) {
           if (min >= 1) return failAt2(pos);
@@ -2217,6 +2301,7 @@ function sepBy(combinator, separator, opts = {}) {
         const sep2 = separator.parse(input, sepPos, ctx);
         if (!sep2.ok) {
           rollbackTrivia(ctx, loopMark);
+          if (sep2.committed) return sep2;
           break;
         }
         const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
@@ -2232,6 +2317,7 @@ function sepBy(combinator, separator, opts = {}) {
         }
         const next = combinator.parse(input, nextPos, ctx);
         if (!next.ok) {
+          if (next.committed) return next;
           const term = ctx._tolerant ? ctx._sync : void 0;
           if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
             expected ??= deriveExpected(combinator);
@@ -2287,6 +2373,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;
@@ -2358,6 +2449,16 @@ function tagRule(r, key) {
   r._ruleName = key;
   if (r._def.tag === "node" && r._def.type === void 0) r._def.type = key;
 }
+function isDefinableRef(v2) {
+  return !!v2 && typeof v2 === "object" && "_def" in v2 && v2._def.tag === "lazy" && typeof v2.define === "function";
+}
+function ruleNameOf(r) {
+  return r._ruleName;
+}
+function isNamedRuleRefForAnotherRule(r, key) {
+  const name = r._def.tag === "lazy" ? ruleNameOf(r) : void 0;
+  return name !== void 0 && name !== key;
+}
 function rules(a, b) {
   const factory = typeof a === "function" ? a : b;
   const options = typeof a === "function" ? b : a;
@@ -2378,11 +2479,21 @@ function rules(a, b) {
   for (const key of Object.keys(definitions)) {
     const placeholder = cache[key];
     const parser2 = definitions[key];
-    if (placeholder !== void 0 && typeof placeholder.define === "function") {
-      tagRule(parser2, key);
+    if (placeholder === parser2) {
+      throw new Error(`rules(): rule "${key}" cannot be a direct alias to itself`);
+    }
+    if (isDefinableRef(placeholder)) {
+      if (!isNamedRuleRefForAnotherRule(parser2, key)) tagRule(parser2, key);
       placeholder.define(parser2);
       placeholder._meta.firstSet = parser2._meta.firstSet;
       placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else if (isNamedRuleRefForAnotherRule(parser2, key)) {
+      const alias = ref();
+      tagRule(alias, key);
+      alias.define(parser2);
+      alias._meta.firstSet = parser2._meta.firstSet;
+      alias._meta.canMatchNewline = parser2._meta.canMatchNewline;
+      cache[key] = alias;
     } else {
       tagRule(parser2, key);
       cache[key] = parser2;
@@ -2542,6 +2653,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":
@@ -2609,6 +2722,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": {
@@ -2634,6 +2749,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":
@@ -3008,7 +3125,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.37.0";
+var PARSEMAN_VERSION = "0.39.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3062,7 +3179,7 @@ function firstSetToString(fs2) {
   if (fs2.kind === "empty") return "(empty)";
   return fs2.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
-var ruleNameOf = (p) => p._ruleName;
+var ruleNameOf2 = (p) => p._ruleName;
 var SUGGESTIONS = {
   "broad-recognizer": "if this arm leads with a keyword regex, use word('kw', boundary) / keywords([...]) \u2014 they expose an EXACT, gating first-set and lower to the same charCodeAt scan. A genuine scanTo fallback is fine; accept it in the gating snapshot if intentional.",
   "leading-not": "let the arm lead with its actual consuming terminal (first-sets gate it automatically); keep not(...) only as a TRAILING boundary. Do not hand-roll not(not(...)) to fake gating \u2014 use peek(X), which is zero-width AND carries X first-set.",
@@ -3164,6 +3281,8 @@ function classifyBroadArm(arm, resolve2) {
         }
         return null;
       }
+      case "dispatch":
+        return walk2(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
@@ -3220,7 +3339,7 @@ function detectAntiPatterns(rule, arms) {
   return out;
 }
 function analyzeGating(entry, opts) {
-  return analyzeGatingRules([[ruleNameOf(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeGatingRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function analyzeGatingRules(ruleMap, opts) {
   const raw = [];
@@ -3253,7 +3372,7 @@ function analyzeGatingRules(ruleMap, opts) {
       return;
     }
     const d = def;
-    const rule = ruleNameOf(p) ?? enclosingRule;
+    const rule = ruleNameOf2(p) ?? enclosingRule;
     if (d.tag === "choice") {
       raw.push({ g: analyzeChoice(p, d, rule, opts?.resolveRef), rule });
       antiPatterns.push(...detectAntiPatterns(rule, d.parsers));
@@ -3263,6 +3382,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 {
@@ -3272,7 +3396,7 @@ function analyzeGatingRules(ruleMap, opts) {
     }
     for (const k of kids) visit(k, rule);
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf(root) ?? name);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name);
   const perRule = /* @__PURE__ */ new Map();
   for (const r of raw) perRule.set(r.rule, (perRule.get(r.rule) ?? 0) + 1);
   const seenInRule = /* @__PURE__ */ new Map();
@@ -3369,6 +3493,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":
@@ -3396,7 +3526,7 @@ function childrenOf(d) {
     }
   }
 }
-var ruleNameOf2 = (p) => p._ruleName;
+var ruleNameOf3 = (p) => p._ruleName;
 var fnKey = (src, fn) => src ?? (typeof fn === "function" ? String(fn) : "");
 function payloadKey(p, d) {
   switch (d.tag) {
@@ -3407,7 +3537,7 @@ function payloadKey(p, d) {
     case "keywords":
       return `keywords\0${[...d.words].join("
")}\0${d.caseInsensitive}\0${d.boundary ?? ""}`;
     case "lazy": {
-      const n = ruleNameOf2(p);
+      const n = ruleNameOf3(p);
       return n === void 0 ? `ref\0#${anonId(p)}` : `ref\0${n}`;
     }
     case "label":
@@ -3425,6 +3555,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":
@@ -3474,7 +3606,7 @@ var Interner = class {
 var MAX_RENDER = 160;
 function render(p, depth = 3) {
   const d = p._def;
-  const name = ruleNameOf2(p);
+  const name = ruleNameOf3(p);
   switch (d.tag) {
     case "literal":
       return `literal('${d.value}')`;
@@ -3496,6 +3628,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":
@@ -3519,6 +3656,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":
@@ -3653,7 +3794,7 @@ function keywordAlternationHazards(words, boundary) {
   return out;
 }
 function analyzeDuplication(entry, opts) {
-  return analyzeDuplicationRules([[ruleNameOf2(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
+  return analyzeDuplicationRules([[ruleNameOf3(entry) ?? opts?.entryName ?? "<entry>", entry]], opts);
 }
 function assertAnalyzable(ruleMap) {
   for (const [name, rule] of ruleMap) {
@@ -3694,7 +3835,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
   const visit = (p, rule, path2, enclosingNode, enclosingReducer) => {
     if (visited.has(p)) return;
     const d = p._def;
-    const own = ruleNameOf2(p);
+    const own = ruleNameOf3(p);
     const here = own !== void 0 && own !== rule ? { rule: own, path: "" } : { rule, path: path2 };
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
@@ -3707,12 +3848,12 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (d.tag === "lazy") {
       try {
         const target = d.thunk();
-        visit(target, ruleNameOf2(target) ?? ruleNameOf2(p) ?? here.rule, "", null, false);
+        visit(target, ruleNameOf3(target) ?? ruleNameOf3(p) ?? here.rule, "", null, false);
       } catch {
       }
     }
   };
-  for (const [name, root] of ruleMap) visit(root, ruleNameOf2(root) ?? name, "", null, false);
+  for (const [name, root] of ruleMap) visit(root, ruleNameOf3(root) ?? name, "", null, false);
   const accept = new Set(opts?.accept ?? []);
   const used = /* @__PURE__ */ new Set();
   const keep = (f) => {
@@ -4772,6 +4913,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":
@@ -6236,6 +6379,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) {
@@ -6318,6 +6463,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) {
@@ -6354,15 +6502,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();
@@ -6575,6 +6730,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.
@@ -6619,6 +6776,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);
@@ -6640,6 +6841,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":
@@ -6686,6 +6889,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;
@@ -6699,6 +6903,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`,
@@ -6707,7 +6912,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) {
@@ -7084,6 +7289,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);
@@ -7205,12 +7522,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}) {`);
@@ -7225,7 +7546,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");
@@ -7249,10 +7572,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} }`);
@@ -7409,7 +7734,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");
@@ -7428,7 +7754,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}++`);
@@ -7440,10 +7767,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}`
   ];
@@ -7475,7 +7804,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
@@ -7489,18 +7818,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`,
@@ -7529,6 +7861,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`,
@@ -7539,6 +7872,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(
@@ -7567,16 +7901,18 @@ function emitSepBy(_p, def, ctx, pos) {
       );
       sepAtPos = spV;
       const rollbackToSep = `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markV}) _ctx._cstRawChildren.length = ${markV}; if (_ctx._cstTriviaLog && _ctx._cstTriviaLog.length !== ${markTl}) _ctx._cstTriviaLog.length = ${markTl}; if (_ctx._triviaLog && _ctx._triviaLog.length !== ${markLog}) _ctx._triviaLog.length = ${markLog}; `;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}break }`);
+      const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${rollbackToSep}${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const post = postSepMarks();
       stmts.push(...post.decl);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${capFn}(input, ${sepEnd}, _ctx, 1)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
+      const next = emitFallible(def.parser, ctx, npV, true);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, itemFailBreak(sepEnd, rollbackToSep, post.rb)),
+        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, rollbackToSep, post.rb)),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -7585,14 +7921,16 @@ function emitSepBy(_p, def, ctx, pos) {
       const spV = v(ctx, "_sp");
       stmts.push(`${ind(ctx)}const ${spV} = ${trivFn}(input, ${curV}, _ctx)`);
       sepAtPos = spV;
-      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+      const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+      const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+      stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
       const npV = v(ctx, "_np");
       stmts.push(`${ind(ctx)}const ${npV} = ${trivFn}(input, ${sepEnd}, _ctx)`);
-      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, npV, true);
+      const next = emitFallible(def.parser, ctx, npV, true);
+      const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
       stmts.push(
         ...nextStmts,
-        ...failItem(nextOk, npV, itemFailBreak(sepEnd, "", "")),
+        ...failItem(nextOk, next.mayCommit, npV, itemFailBreak(sepEnd, "", "")),
         `${ind(ctx)}${arrV}.push(${nextVal})`,
         `${ind(ctx)}${curV} = ${nextEnd}`
       );
@@ -7606,15 +7944,17 @@ function emitSepBy(_p, def, ctx, pos) {
         `${ind(ctx)}const ${markRw} = _ctx._cstRawChildren ? _ctx._cstRawChildren.length : 0`
       );
     }
-    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = emitFallible(def.separator, ctx, sepAtPos, true);
-    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) break`);
+    const sep2 = emitFallible(def.separator, ctx, sepAtPos, true);
+    const { stmts: sepStmts, okVar: sepOk, endVar: sepEnd } = sep2;
+    stmts.push(...sepStmts, `${ind(ctx)}if (!${sepOk}) { ${sep2.mayCommit ? `if (_ctx._fc) ${committedFailBody(ctx)}; ` : ""}break }`);
     const nextRb = markLv ? `if (_ctx._cstLeaves && _ctx._cstLeaves.length !== ${markLv}) _ctx._cstLeaves.length = ${markLv}; if (_ctx._cstRawChildren && _ctx._cstRawChildren.length !== ${markRw}) _ctx._cstRawChildren.length = ${markRw}; ` : "";
     const post = postSepMarks();
     stmts.push(...post.decl);
-    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = emitFallible(def.parser, ctx, sepEnd, true);
+    const next = emitFallible(def.parser, ctx, sepEnd, true);
+    const { stmts: nextStmts, okVar: nextOk, valVar: nextVal, endVar: nextEnd } = next;
     stmts.push(
       ...nextStmts,
-      ...failItem(nextOk, sepEnd, itemFailBreak(sepEnd, nextRb, post.rb)),
+      ...failItem(nextOk, next.mayCommit, sepEnd, itemFailBreak(sepEnd, nextRb, post.rb)),
       `${ind(ctx)}${arrV}.push(${nextVal})`,
       `${ind(ctx)}${curV} = ${nextEnd}`
     );
@@ -7995,7 +8335,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),
@@ -8076,7 +8416,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 = [
@@ -8088,6 +8428,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`,
@@ -8098,7 +8439,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;
@@ -8138,14 +8479,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;
@@ -8178,6 +8519,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":
@@ -8398,6 +8741,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":
@@ -8431,6 +8776,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":
@@ -8474,6 +8821,7 @@ function childrenOf2(def) {
 var HOISTABLE_TAGS = /* @__PURE__ */ new Set([
   "sequence",
   "choice",
+  "dispatch",
   "many",
   "oneOrMore",
   "optional",
@@ -8567,7 +8915,7 @@ function ruleDependencies(ruleMap) {
     const seen = /* @__PURE__ */ new Set();
     const walk2 = (p, isRoot) => {
       const def = p._def;
-      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
         found.add(boundary);
         return;
@@ -9298,6 +9646,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":
@@ -9332,7 +9682,7 @@ function childrenOf3(def) {
       return [];
   }
 }
-var ruleNameOf3 = (c) => c._ruleName;
+var ruleNameOf4 = (c) => c._ruleName;
 function lazyTarget(c) {
   if (c._def.tag !== "lazy") return null;
   try {
@@ -9447,6 +9797,9 @@ function evalRuleMapIR(ir) {
     "keywords",
     "sequence",
     "choice",
+    "dispatch",
+    "when",
+    "otherwise",
     "attempt",
     "many",
     "oneOrMore",
@@ -9480,6 +9833,9 @@ function evalRuleMapIR(ir) {
     keywords,
     sequence,
     choice,
+    dispatch,
+    when,
+    otherwise,
     attempt,
     many,
     oneOrMore,
@@ -9514,12 +9870,16 @@ var Serializer = class {
   emitted = /* @__PURE__ */ new Set();
   decls = [];
   ruleValues = /* @__PURE__ */ new Set();
+  localRuleNames = /* @__PURE__ */ new Map();
   ruleMap;
   scanSkip;
   constructor(ruleMap, scanSkip = []) {
     this.ruleMap = ruleMap;
     this.scanSkip = scanSkip;
-    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+    for (const [name, c] of ruleMap) {
+      this.localRuleNames.set(c, name);
+      this.ruleValues.add(this.body(c));
+    }
   }
   /** A grammar-level `scanSkip` unit is an opaque TERMINAL (a string, a balanced
    * bracket) — it must not reach a grammar-rule ref (`g[name]`), because the
@@ -9530,7 +9890,7 @@ var Serializer = class {
     if (seen.has(c)) return;
     seen.add(c);
     if (c._def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
+      if (ruleNameOf4(c) !== void 0) throw new Unserializable("scanSkip unit references a grammar rule");
       const target = lazyTarget(c);
       if (target) this.assertNoRuleRef(target, seen);
       return;
@@ -9541,7 +9901,7 @@ var Serializer = class {
    * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
    * `g[name]` ref — only the top-level entry is unwrapped. */
   body(c) {
-    return c._def.tag === "lazy" && ruleNameOf3(c) !== void 0 ? lazyTarget(c) ?? c : c;
+    return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
@@ -9583,7 +9943,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
   analyze(c, active) {
     const def = c._def;
     if (def.tag === "lazy") {
-      if (ruleNameOf3(c) !== void 0) return;
+      if (ruleNameOf4(c) !== void 0) return;
       const target = lazyTarget(c);
       if (!target) throw new Unserializable("unresolved unnamed ref");
       if (active.has(target)) {
@@ -9635,7 +9995,8 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     const kid = (x) => this.ref(x, selfOf);
     switch (def.tag) {
       case "lazy": {
-        if (ruleNameOf3(c) !== void 0) return `g[${JSON.stringify(ruleNameOf3(c))}]`;
+        const name = this.localRuleNames.get(c) ?? ruleNameOf4(c);
+        if (name !== void 0) return `g[${JSON.stringify(name)}]`;
         const target = lazyTarget(c);
         if (selfOf && target === selfOf.comb) return selfOf.var;
         return this.ref(target, selfOf);
@@ -9660,6 +10021,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
@@ -10145,6 +10513,28 @@ function stripTsFromSource(node2, code) {
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
 }
+function isStaticValueEntry(v2) {
+  return !!v2 && typeof v2 === "object" && "value" in v2 && "mfSrcs" in v2;
+}
+function wordFactoryFromArgs(args, scope, code, mfs) {
+  const [boundaryOrOptsArg, optsArg] = args;
+  if (boundaryOrOptsArg?.type === "SpreadElement" || optsArg?.type === "SpreadElement") return null;
+  const rawBoundaryOrOpts = boundaryOrOptsArg === void 0 ? void 0 : anyValue(boundaryOrOptsArg, scope, code, mfs);
+  const boundaryOrOpts = rawBoundaryOrOpts === void 0 ? "_0-9A-Za-z" : rawBoundaryOrOpts;
+  const opts = optsArg === void 0 ? void 0 : anyValue(optsArg, scope, code, mfs);
+  if (typeof boundaryOrOpts === "string") {
+    if (opts !== void 0 && (typeof opts !== "object" || opts === null || Array.isArray(opts))) return null;
+    const caseInsensitive2 = typeof opts === "object" && opts !== null && "caseInsensitive" in opts ? opts.caseInsensitive : false;
+    if (typeof caseInsensitive2 !== "boolean") return null;
+    return { tag: "wordFactory", boundary: boundaryOrOpts, caseInsensitive: caseInsensitive2 };
+  }
+  if (typeof boundaryOrOpts !== "object" || boundaryOrOpts === null || Array.isArray(boundaryOrOpts) || opts !== void 0) {
+    return null;
+  }
+  const caseInsensitive = "caseInsensitive" in boundaryOrOpts ? boundaryOrOpts.caseInsensitive : false;
+  if (typeof caseInsensitive !== "boolean") return null;
+  return { tag: "wordFactory", boundary: "_0-9A-Za-z", caseInsensitive };
+}
 var SUPPORTED = {
   literal: (...a) => literal(a[0], a[1]),
   regex: (...a) => regex(a[0], a[1]),
@@ -10195,9 +10585,41 @@ function gatedArmParts(e) {
   }
   return gate2 && combinator ? { gate: gate2, combinator } : null;
 }
+function dispatchArmValue(node2, scope, code, mfs) {
+  if (node2.type === "Identifier") {
+    const value = anyValue(node2, scope, code, mfs);
+    return isDispatchArm(value) ? value : null;
+  }
+  if (node2.type !== "CallExpression") return null;
+  const callee = node2.callee;
+  if (callee.type !== "Identifier") return null;
+  if (callee.name === "otherwise") {
+    const [parserArg] = node2.arguments;
+    if (!parserArg || parserArg.type === "SpreadElement") return null;
+    const parserValue = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(parserValue)) return null;
+    return otherwise(parserValue);
+  }
+  if (callee.name === "when") {
+    const [keyArg, parserArg] = node2.arguments;
+    if (!keyArg || !parserArg || keyArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
+    const key = anyValue(keyArg, scope, code, mfs);
+    const parserValue = anyValue(parserArg, scope, code, mfs);
+    if (!isCombinator(parserValue)) return null;
+    if (typeof key === "string") return when(key, parserValue);
+    if (Array.isArray(key) && key.every((item) => typeof item === "string")) return when(key, parserValue);
+  }
+  return null;
+}
 function isCombinator(v2) {
   return !!v2 && typeof v2 === "object" && "_def" in v2;
 }
+function isDispatchArm(v2) {
+  if (!v2 || typeof v2 !== "object") return false;
+  const rec = v2;
+  if (rec.kind === "otherwise") return isCombinator(rec.parser);
+  return rec.kind === "when" && Array.isArray(rec.keys) && rec.keys.every((key) => typeof key === "string") && isCombinator(rec.parser);
+}
 function scopeGet(scope, name, mfs) {
   const entry = scope.get(name);
   if (!entry) return null;
@@ -10228,14 +10650,13 @@ function exprToCombi(node2, scope, code, mfs) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type === "CallExpression" && callee.callee.type === "Identifier" && callee.callee.name === "makeWord") {
-    const boundaryArg = callee.arguments[0];
     const strArg = node2.arguments[0];
     if (!strArg || strArg.type === "SpreadElement") return null;
-    const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
+    const factory2 = wordFactoryFromArgs(callee.arguments, scope, code, mfs);
     const str = anyValue(strArg, scope, code, mfs);
-    if (typeof boundary !== "string" || typeof str !== "string") return null;
+    if (factory2 === null || typeof str !== "string") return null;
     try {
-      return word(str, boundary);
+      return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
     } catch {
       return null;
     }
@@ -10248,7 +10669,7 @@ function exprToCombi(node2, scope, code, mfs) {
       const str = anyValue(strArg, scope, code, mfs);
       if (typeof str !== "string") return null;
       try {
-        return word(str, factory2.boundary);
+        return word(str, factory2.boundary, { caseInsensitive: factory2.caseInsensitive });
       } catch {
         return null;
       }
@@ -10455,6 +10876,25 @@ function exprToCombi(node2, scope, code, mfs) {
       return null;
     }
   }
+  if (callee.name === "dispatch") {
+    const [selectorArg, ...armArgs] = node2.arguments;
+    if (!selectorArg || selectorArg.type === "SpreadElement") return null;
+    const selector = anyValue(selectorArg, scope, code, mfs);
+    if (!isCombinator(selector)) return null;
+    const arms = [];
+    for (const arg of armArgs) {
+      if (arg.type === "SpreadElement") return null;
+      const arm = dispatchArmValue(arg, scope, code, mfs);
+      if (!isDispatchArm(arm)) return null;
+      arms.push(arm);
+    }
+    try {
+      const unsafeDispatch = dispatch;
+      return unsafeDispatch(selector, ...arms);
+    } catch {
+      return null;
+    }
+  }
   if (callee.name === "choice" && node2.arguments.some((a) => a.type !== "SpreadElement" && isGatedArmExpr(a))) {
     if (code === void 0 || mfs === void 0) return null;
     const arms = [];
@@ -10540,6 +10980,10 @@ function anyValue(node2, scope, code, mfs) {
       if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
       return entry.combi;
     }
+    if (isStaticValueEntry(entry)) {
+      if (mfs && entry.mfSrcs.length > 0) mfs.push(...entry.mfSrcs);
+      return entry.value;
+    }
     return entry;
   }
   if (node2.type === "MemberExpression") {
@@ -10558,10 +11002,10 @@ function anyValue(node2, scope, code, mfs) {
   if (node2.type === "CallExpression") {
     const callee = node2.callee;
     if (callee.type === "Identifier" && callee.name === "makeWord") {
-      const boundaryArg = node2.arguments[0];
-      const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code, mfs) : "_0-9A-Za-z";
-      if (typeof boundary !== "string") return null;
-      return { tag: "wordFactory", boundary };
+      return wordFactoryFromArgs(node2.arguments, scope, code, mfs);
+    }
+    if (callee.type === "Identifier" && (callee.name === "when" || callee.name === "otherwise")) {
+      return dispatchArmValue(node2, scope, code, mfs);
     }
     return exprToCombi(node2, scope, code, mfs);
   }
@@ -10571,10 +11015,7 @@ function evaluateWordFactory(node2, scope, code) {
   if (node2.type !== "CallExpression") return null;
   const callee = node2.callee;
   if (callee.type !== "Identifier" || callee.name !== "makeWord") return null;
-  const boundaryArg = node2.arguments[0];
-  const boundary = boundaryArg && boundaryArg.type !== "SpreadElement" ? anyValue(boundaryArg, scope, code) : "_0-9A-Za-z";
-  if (typeof boundary !== "string") return null;
-  return { tag: "wordFactory", boundary };
+  return wordFactoryFromArgs(node2.arguments, scope, code);
 }
 function evaluateExpr(node2, scope, code, mapFnSources) {
   return exprToCombi(node2, scope, code, mapFnSources);
@@ -10624,6 +11065,7 @@ function evalBodyStatements(statements, scope, code) {
       if (val === null) return false;
       const thisDeclMfSrcs = bodyMfs.slice(before);
       if (isCombinator(val)) scope.set(name, { combi: val, mfSrcs: thisDeclMfSrcs });
+      else if (isDispatchArm(val)) scope.set(name, { value: val, mfSrcs: thisDeclMfSrcs });
       else scope.set(name, val);
     }
   }
@@ -10669,6 +11111,11 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
     r._ruleName = name;
     if (r._def.tag === "node" && r._def.type === void 0) r._def.type = name;
   };
+  const ruleNameOf5 = (r) => r._ruleName;
+  const isNamedRuleRefForAnotherRule2 = (r, key) => {
+    const name = r._def.tag === "lazy" ? ruleNameOf5(r) : void 0;
+    return name !== void 0 && name !== key;
+  };
   for (const key of keys) {
     if (!ruleRefs.has(key)) {
       const r = ref();
@@ -10699,12 +11146,15 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   for (const [key, e] of finalByKey) {
     const val = anyValue(e.value, e.scope, e.code, mapFnSources);
     if (!isCombinator(val)) return null;
-    tagRef(val, key);
+    if (val === ruleRefs.get(key)) return null;
+    if (!isNamedRuleRefForAnotherRule2(val, key)) {
+      tagRef(val, key);
+    }
     ruleRefs.get(key).define(val);
   }
   return ruleRefs;
 }
-function isDefinableRef(v2) {
+function isDefinableRef2(v2) {
   return isCombinator(v2) && typeof v2.define === "function" && v2._def.tag === "lazy";
 }
 function evaluateRefDeclaration(init, name, scope) {
@@ -10726,7 +11176,7 @@ function applyDefineStatement(callExpr, scope, code) {
   if (mem.object.type !== "Identifier" || !mem.object.name) return false;
   const target = scope.get(mem.object.name);
   const refCombi = isScopeEntry(target) ? target.combi : isCombinator(target) ? target : null;
-  if (!refCombi || !isDefinableRef(refCombi)) return false;
+  if (!refCombi || !isDefinableRef2(refCombi)) return false;
   const args = callExpr.arguments;
   if (args.length !== 1 || args[0].type === "SpreadElement") return false;
   const inner = anyValue(args[0], scope, code, []);