parseman 0.49.0 → 0.50.1

package/dist/plugin/index.js

@@ -2,7 +2,7 @@
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 import { createUnplugin } from "unplugin";
-import { parseSync as parseSync4 } from "oxc-parser";
+import { parseSync as parseSync5 } from "oxc-parser";
 import { ResolverFactory } from "oxc-resolver";
 import MagicString from "magic-string";
 
@@ -27,9 +27,9 @@ function classifyFinalChoice(arms, resolve3) {
         break;
       }
       let ownsHigh = false;
-      for (const range of first.ranges) {
-        if (range.hi >= 128) ownsHigh = true;
-        for (let code = Math.max(0, range.lo); code <= Math.min(127, range.hi); code++) {
+      for (const range2 of first.ranges) {
+        if (range2.hi >= 128) ownsHigh = true;
+        for (let code = Math.max(0, range2.lo); code <= Math.min(127, range2.hi); code++) {
           if (ascii[code] !== 0) {
             exclusive = false;
             break;
@@ -551,10 +551,10 @@ function beginCstNodeCapture(ctx) {
 }
 function finishCstBuf(buf) {
   if (!buf) return { children: EMPTY, rawChildren: EMPTY, triviaLog: EMPTY_TL };
-  const children2 = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY);
-  const rawChildren = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY);
+  const children3 = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY);
+  const rawChildren = buf.noRaw === true ? EMPTY : buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY);
   const triviaLog = buf.tl ?? EMPTY_TL;
-  return { children: children2, rawChildren, triviaLog };
+  return { children: children3, rawChildren, triviaLog };
 }
 function endCstNodeCapture(ctx, saved) {
   const materialized = finishCstBuf(ctx._cstBuf);
@@ -584,7 +584,8 @@ function pushCstChild(ctx, built, rawEntry2) {
         b.single = void 0;
       } else b.single = built;
     }
-    if (b.raw) b.raw.push(rawEntry2);
+    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 0) + 1;
+    else if (b.raw) b.raw.push(rawEntry2);
     else if (b.rawSingle !== void 0) {
       b.raw = [b.rawSingle, rawEntry2];
       b.rawSingle = void 0;
@@ -598,6 +599,7 @@ function pushCstChild(ctx, built, rawEntry2) {
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
   if (b) {
+    if (b.noRaw === true) return b.rawLen ?? 0;
     if (b.raw) return b.raw.length;
     return b.rawSingle !== void 0 ? 1 : 0;
   }
@@ -657,19 +659,37 @@ function rollbackCstCaptureAt(ctx, raw, tlog, leaves, fields, errors) {
   if (ctx._errors && errors !== void 0 && ctx._errors.length !== errors) ctx._errors.length = errors;
   const b = ctx._cstBuf;
   if (b) {
-    rollbackBufList(b, "raw", "rawSingle", raw);
-    rollbackBufList(b, "ch", "single", leaves);
+    if (b.noRaw === true) {
+      if (b.rawLen !== raw) b.rawLen = raw;
+    } else {
+      const rawList = b.raw;
+      if (rawList) {
+        if (raw === 0) b.raw = void 0;
+        else if (raw === 1) {
+          b.rawSingle = rawList[0];
+          b.raw = void 0;
+        } else if (rawList.length !== raw) rawList.length = raw;
+      } else if (raw === 0) b.rawSingle = void 0;
+    }
+    const childList = b.ch;
+    if (childList) {
+      if (leaves === 0) b.ch = void 0;
+      else if (leaves === 1) {
+        b.single = childList[0];
+        b.ch = void 0;
+      } else if (childList.length !== leaves) childList.length = leaves;
+    } else if (leaves === 0) b.single = void 0;
     if (b.tl) {
       if (tlog === 0) b.tl = void 0;
       else if (b.tl.length !== tlog) b.tl.length = tlog;
     }
-    if (ctx._fields && ctx._fields.length !== fields) ctx._fields.length = fields;
+    if (ctx._fields && fields !== void 0 && ctx._fields.length !== fields) ctx._fields.length = fields;
     return;
   }
   if (ctx._cstRawChildren && ctx._cstRawChildren.length !== raw) ctx._cstRawChildren.length = raw;
   if (ctx._cstTriviaLog && ctx._cstTriviaLog.length !== tlog) ctx._cstTriviaLog.length = tlog;
   if (ctx._cstLeaves && ctx._cstLeaves.length !== leaves) ctx._cstLeaves.length = leaves;
-  if (ctx._fields && ctx._fields.length !== fields) ctx._fields.length = fields;
+  if (ctx._fields && fields !== void 0 && ctx._fields.length !== fields) ctx._fields.length = fields;
 }
 function pushCstTriviaEntry(ctx, start, end, kindIndex) {
   const insertIdx = cstRawLen(ctx);
@@ -2158,15 +2178,22 @@ function canConsumeNewline(n) {
       return n.parts.some(canConsumeNewline);
   }
 }
+function regexCanMatchEmpty(source) {
+  try {
+    return nullable(parseRegex(source));
+  } catch {
+    return true;
+  }
+}
 function firstSetFromRegex(source) {
-  let ast;
+  let ast2;
   try {
-    ast = parseRegex(source);
+    ast2 = parseRegex(source);
   } catch {
     return { firstSet: any(), canMatchNewline: true };
   }
-  if (nullable(ast)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast) };
-  return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
+  if (nullable(ast2)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast2) };
+  return { firstSet: firstSet(ast2), canMatchNewline: canConsumeNewline(ast2) };
 }
 
 // src/combinators/regex.ts
@@ -3789,21 +3816,21 @@ function when(key, parser2, opts = {}) {
 function otherwise(parser2) {
   return { kind: "otherwise", parser: parser2, usesRouted: parserUsesRouted(parser2) };
 }
-function routed(fallback) {
+function routed(fallback2) {
   return {
     _tag: "routed",
     _meta: {
       // The routed token is whatever the selector matched, so the first set stays
       // `any` even with a fallback — `any` already subsumes the fallback's.
       firstSet: { kind: "any" },
-      canMatchNewline: fallback?._meta.canMatchNewline ?? false,
+      canMatchNewline: fallback2?._meta.canMatchNewline ?? false,
       isTrivia: false
     },
-    _def: fallback === void 0 ? { tag: "routed" } : { tag: "routed", fallback },
+    _def: fallback2 === void 0 ? { tag: "routed" } : { tag: "routed", fallback: fallback2 },
     parse(_input, pos, ctx) {
       const item = ctx._routed;
       if (item === void 0 || pos !== item.span.start) {
-        if (fallback !== void 0) return fallback.parse(_input, pos, ctx);
+        if (fallback2 !== void 0) return fallback2.parse(_input, pos, ctx);
         return { ok: false, expected: ["routed()"], span: { start: pos, end: pos } };
       }
       if (cstCaptureActive(ctx)) {
@@ -3817,7 +3844,7 @@ function dispatch(selector, ...arms) {
   if (parserUsesRouted(selector)) {
     throw new Error("parseman: routed() can only appear inside a dispatch() branch");
   }
-  let fallback;
+  let fallback2;
   let fallbackUsesRouted = false;
   const matchers = [];
   const cases = [];
@@ -3825,9 +3852,9 @@ function dispatch(selector, ...arms) {
   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 (fallback2 !== 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;
+      fallback2 = arm.parser;
       fallbackUsesRouted = arm.usesRouted === true;
       continue;
     }
@@ -3860,7 +3887,7 @@ function dispatch(selector, ...arms) {
   }
   const meta = {
     firstSet: selector._meta.firstSet,
-    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || matchers.some((entry) => entry.parser._meta.canMatchNewline) || (fallback?._meta.canMatchNewline ?? false),
+    canMatchNewline: selector._meta.canMatchNewline || cases.some((entry) => entry.parser._meta.canMatchNewline) || matchers.some((entry) => entry.parser._meta.canMatchNewline) || (fallback2?._meta.canMatchNewline ?? false),
     isTrivia: false
   };
   const byKey = /* @__PURE__ */ new Map();
@@ -3879,7 +3906,7 @@ function dispatch(selector, ...arms) {
       selector,
       cases,
       ...matchers.length === 0 ? {} : { matchers },
-      ...fallback === void 0 ? {} : { otherwise: fallback, ...fallbackUsesRouted ? { otherwiseUsesRouted: true } : {} }
+      ...fallback2 === void 0 ? {} : { otherwise: fallback2, ...fallbackUsesRouted ? { otherwiseUsesRouted: true } : {} }
     },
     parse(input, pos, ctx) {
       if (parserUsesRouted(selector)) {
@@ -3888,7 +3915,7 @@ function dispatch(selector, ...arms) {
       const selectorMark = saveTriviaMark(ctx);
       const selected = selector.parse(input, pos, ctx);
       if (!selected.ok) return selected;
-      const branch = byKey.get(selected.value) ?? (byFoldedKey.size === 0 ? void 0 : byFoldedKey.get(asciiFoldKey(selected.value))) ?? matchers.find((matcher) => matchesDispatchMatcher(selected.value, matcher)) ?? (fallback === void 0 ? void 0 : { keys: [], parser: fallback, caseInsensitive: false, usesRouted: fallbackUsesRouted });
+      const branch = byKey.get(selected.value) ?? (byFoldedKey.size === 0 ? void 0 : byFoldedKey.get(asciiFoldKey(selected.value))) ?? matchers.find((matcher) => matchesDispatchMatcher(selected.value, matcher)) ?? (fallback2 === void 0 ? void 0 : { keys: [], parser: fallback2, caseInsensitive: false, usesRouted: fallbackUsesRouted });
       if (branch === void 0) {
         const expected = cases.flatMap((entry) => entry.keys.map((key) => JSON.stringify(key)));
         return { ok: false, expected, span: { start: selected.span.end, end: selected.span.end } };
@@ -4385,6 +4412,7 @@ var SINGLE_IDENT_ARROW_RE = /^[A-Za-z_$][\w$]*\s*=>/;
 var PARAM_LIST_OPEN_RE = /^(?:function\b[^(]*)?\(/;
 var NATIVE_CODE_RE = /\{\s*\[native code\]\s*\}/;
 var PARAM_HEAD_RE = /^[A-Za-z_$][\w$]*\s*\??\s*/;
+var PARAM_NAME_RE = /^([A-Za-z_$][\w$]*)\s*\??\s*/;
 function confirmedBuildArity(src) {
   const s = src.trim();
   if (NATIVE_CODE_RE.test(s)) return null;
@@ -4400,6 +4428,34 @@ function confirmedBuildArity(src) {
   }
   return parts.length;
 }
+function confirmedBuildParamUnused(src, index) {
+  if (!Number.isInteger(index) || index < 0) return false;
+  const s = src.trim();
+  if (NATIVE_CODE_RE.test(s) || /\b(?:arguments|eval|Function)\b/.test(s) || /\bwith\s*\(/.test(s)) return false;
+  let names;
+  const single = /^([A-Za-z_$][\w$]*)\s*=>/.exec(s);
+  if (single) {
+    names = [single[1]];
+  } else {
+    const inner = paramListText(s);
+    if (inner === null || inner.trim() === "") return false;
+    const parts = splitTopLevel(inner);
+    if (parts === null) return false;
+    names = [];
+    for (const part of parts) {
+      const trimmed = part.trim();
+      if (!isConfirmableParam(trimmed)) return false;
+      const name2 = PARAM_NAME_RE.exec(trimmed)?.[1];
+      if (name2 === void 0) return false;
+      names.push(name2);
+    }
+  }
+  const name = names[index];
+  if (name === void 0) return false;
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const uses = s.match(new RegExp(`(^|[^A-Za-z0-9_$])${escaped}(?=$|[^A-Za-z0-9_$])`, "g"));
+  return uses?.length === 1;
+}
 function paramListText(s) {
   const open = PARAM_LIST_OPEN_RE.exec(s);
   if (!open) return null;
@@ -4537,6 +4593,7 @@ function confirmedArityForDef(def) {
 }
 function buildReadsRaw(def) {
   if (!def.build) return true;
+  if (def.buildRawUnused === true) return false;
   const arity = confirmedArityForDef(def);
   if (arity === null) return true;
   return arity >= 4;
@@ -4647,11 +4704,11 @@ function normalizeProject(project) {
   }
   return project;
 }
-function projectChild(children2, project, type) {
-  if (!(project in children2)) {
+function projectChild(children3, project, type) {
+  if (!(project in children3)) {
     throw new Error(`node(${JSON.stringify(type)}) project child ${project} was not captured`);
   }
-  return unwrapChild(children2[project]);
+  return unwrapChild(children3[project]);
 }
 function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const hasExplicitType = typeof typeOrCombinator === "string";
@@ -4723,14 +4780,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const fields = effFields ? buildFieldMap(ctx._fields) : void 0;
       ctx._fields = savedFields;
       ctx._triviaCaptureMask = savedMask;
-      const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
+      const { children: children3, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
       const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
       const nodeType = def.type ?? missingInferredType();
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children3.length === 1 ? unwrapChild(children3[0]) : collapse && children3.length === 1 ? children3[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children3.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children3[0], children3, rawChildren) ? children3[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children3, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : build(children3, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children3 };
       const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry2);
@@ -4957,6 +5014,399 @@ function firstSetToString(fs3) {
   return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
 }
 
+// src/analysis/commitment.ts
+function mayFail(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length > 0;
+    case "trivia":
+      return false;
+    // `optional`/`many`/a min-0 `sepBy` swallow an ORDINARY failure — zero
+    // repetitions is a match. They do NOT swallow a COMMITTED one: a dispatch
+    // that has selected an arm and then failed inside it breaks out past every
+    // enclosing repeat, straight to the fallible boundary. So these are total
+    // exactly when their body cannot commit. (Measured: treating them as
+    // unconditionally total left an extra zero-width leaf in
+    // `BareInterpolatedSelector` on benchmark.less — a rollback the legacy
+    // build fired and this one had deleted.)
+    case "optional":
+    case "many":
+      return mayCommitFailure(d.parser);
+    case "sepBy":
+      return d.min >= 1 ? mayFail(d.parser, seen) : mayCommitFailure(d.parser) || mayCommitFailure(d.separator);
+    case "oneOrMore":
+      return mayFail(d.parser, seen);
+    case "sequence":
+      return d.parsers.some((x) => mayFail(x, seen));
+    // Delegating wrappers: as fallible as what they wrap.
+    case "node":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "token":
+    case "leaf":
+      return mayFail(d.parser, seen);
+    case "lazy": {
+      try {
+        return mayFail(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    // An adjacency assertion is a TEST — failing is its whole job.
+    case "adjacency":
+      return true;
+    default:
+      return true;
+  }
+}
+function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    // Atomic / non-capturing-then-failing: a failure happens before any push.
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    // Adjacency probes with `_cap = 0` / no `commit()`: it cannot push anything.
+    case "adjacency":
+    case "not":
+    // peek(): emitted under a non-capturing probe ctx and zero-width on both
+    // outcomes, so it can never leave a partial capture behind.
+    case "peek":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "scanTo":
+    case "unknown":
+      return false;
+    // node() captures into its own private buffers and rolls them back on
+    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
+    case "node":
+      return false;
+    // choice/firstMatch already roll back each failed arm; on overall failure
+    // nothing committed remains.
+    case "choice":
+      return false;
+    case "dispatch":
+      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
+    case "attempt":
+      return false;
+    // optional never fails; many/oneOrMore only "fail" with zero captured items.
+    case "optional":
+    case "many":
+    case "oneOrMore":
+      return false;
+    // sepBy emits its own per-iteration rollback in emitSepBy.
+    case "sepBy":
+      return false;
+    // A sequence is the real case: an earlier capturing term followed by a term
+    // that can fail leaves the earlier captures buffered.
+    //
+    // BOTH halves of that sentence are load-bearing, and the second half is what
+    // this walk exists to exploit. "Some earlier term captures" alone was the old
+    // test, and it is true of very nearly every sequence in a real grammar — a
+    // sequence almost always opens with a literal or a node. The rollback is only
+    // reachable if something AFTER the capture can still fail; once the remainder
+    // is total (`optional`/`many`/trivia/a min-0 `sepBy`), the sequence has no
+    // failure path left to roll back from, and the save+restore is dead code.
+    //
+    // `captured` tracks whether anything is in the buffers yet as the scan moves
+    // left to right. Two things put it there:
+    //   - a term that captures (`capturesLeaf`/`hasNodeDef`), and
+    //   - the inter-term TRIVIA scan, which under `capturing` pushes into
+    //     `_cstRawChildren`/`_cstTriviaLog` BEFORE the term at each boundary
+    //     i >= 1. `emitSeqValues` only rewinds that push on the term's SUCCESS
+    //     path (the "matched empty, so leave the whitespace out of the span"
+    //     branch); a term that FAILS breaks straight out with the trivia still
+    //     buffered, so from boundary 1 onward the buffers are dirty regardless of
+    //     what the earlier terms did.
+    // Each term is also asked about itself: a nested sequence can leave its own
+    // partial capture behind, and its terms are emitted inline into this same
+    // block with no boundary of their own to roll them back.
+    case "sequence": {
+      const parts = d.parsers;
+      let captured = false;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i > 0 && triviaActive) captured = true;
+        if (captured && mayFail(part)) return true;
+        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
+        if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
+      }
+      return false;
+    }
+    // Delegating wrappers: defer to the wrapped parser.
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "recover":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "lazy": {
+      try {
+        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
+      } catch {
+        return true;
+      }
+    }
+    // Unknown shapes: be safe and keep the rollback.
+    default:
+      return true;
+  }
+}
+function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "node":
+    case "token":
+    case "routed":
+    case "leaf":
+      return true;
+    case "not":
+    case "peek":
+    case "guard":
+    case "adjacency":
+    case "trivia":
+    case "unknown":
+      return false;
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => capturesLeaf(x, seen));
+    case "dispatch":
+      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
+    case "sepBy":
+      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "recover":
+      return capturesLeaf(d.parser, seen);
+    case "scanTo":
+      return true;
+    case "lazy": {
+      try {
+        return capturesLeaf(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    default:
+      return true;
+  }
+}
+function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      try {
+        return hasNodeDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "not":
+    case "peek":
+    case "transform":
+      return hasNodeDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "dispatch":
+      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
+    case "scanTo":
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen));
+    case "recover":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
+    case "expect":
+      return hasNodeDef(d.parser, seen);
+    case "withCtx":
+      return hasNodeDef(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
+    case "lazy": {
+      try {
+        return hasDirectBuildDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "attempt":
+    case "not":
+    case "peek":
+    case "withCtx":
+    case "expect":
+    case "transform":
+      return hasDirectBuildDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
+    case "dispatch":
+      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
+    case "scanTo":
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen));
+    case "recover":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
+    case "routed":
+      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
+    default:
+      return false;
+  }
+}
+function mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve3) {
+  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, resolve3));
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+      return mayCommitFailure(d.parser, seen, resolve3);
+    case "sepBy":
+      return mayCommitFailure(d.parser, seen, resolve3) || mayCommitFailure(d.separator, seen, resolve3);
+    case "token":
+    case "leaf":
+      return mayCommitFailure(d.parser, seen, resolve3);
+    case "withCtx":
+      return mayCommitFailure(d.parser, seen, resolve3);
+    case "scanTo":
+      return mayCommitFailure(d.sentinel, seen, resolve3) || d.skip.some((x) => mayCommitFailure(x, seen, resolve3));
+    case "lazy": {
+      try {
+        return mayCommitFailure(d.thunk(), seen, resolve3);
+      } catch {
+        const name = p._ruleName;
+        const target = name === void 0 ? void 0 : resolve3?.(name);
+        return target === void 0 ? true : mayCommitFailure(target, seen, resolve3);
+      }
+    }
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+function hasSemanticReduction(roots, externalRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (parser2) => {
+    if (seen.has(parser2)) return false;
+    seen.add(parser2);
+    const def = parser2._def;
+    if (def.tag === "transform" && !def.recognitionOnly) return true;
+    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
+    if (def.tag === "guard" || def.tag === "withCtx") return true;
+    if (def.tag === "node" && def.build !== void 0) return true;
+    if (def.tag === "lazy") {
+      if (externalRefs?.has(parser2)) return false;
+      try {
+        return visit(def.thunk());
+      } catch {
+        return true;
+      }
+    }
+    return childrenOf2(def).some(visit);
+  };
+  return roots.some(visit);
+}
+function classifyRuleMap(ruleMap) {
+  const externalRefs = /* @__PURE__ */ new Set();
+  const scanned = /* @__PURE__ */ new Set();
+  const scanExternal = (p) => {
+    if (scanned.has(p)) return;
+    scanned.add(p);
+    const def = p._def;
+    if (def.tag === "lazy") {
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        resolved = void 0;
+      }
+      if (resolved === void 0) {
+        if (p._ruleName) externalRefs.add(p);
+        return;
+      }
+      scanExternal(resolved);
+      return;
+    }
+    for (const child of childrenOf2(def)) scanExternal(child);
+  };
+  for (const [, rule] of ruleMap) scanExternal(rule);
+  return {
+    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
+  };
+}
+
 // src/table/ops.ts
 var OP_LIT = 1;
 var OP_RX = 2;
@@ -5273,11 +5723,11 @@ function fixedTreeRunner(words, matchers, classes, expected) {
     }
     if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
       const count = op - LEX_NODE_SEQUENCE2 + 2;
-      const nodes = Array.from({ length: count }, pop).reverse();
-      if (count === 2) stack.push(sequence2(nodes[0], nodes[1]));
-      else if (count === 3) stack.push(sequence3(nodes[0], nodes[1], nodes[2]));
-      else if (count === 4) stack.push(sequence4(nodes[0], nodes[1], nodes[2], nodes[3]));
-      else stack.push(sequence5(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]));
+      const nodes2 = Array.from({ length: count }, pop).reverse();
+      if (count === 2) stack.push(sequence2(nodes2[0], nodes2[1]));
+      else if (count === 3) stack.push(sequence3(nodes2[0], nodes2[1], nodes2[2]));
+      else if (count === 4) stack.push(sequence4(nodes2[0], nodes2[1], nodes2[2], nodes2[3]));
+      else stack.push(sequence5(nodes2[0], nodes2[1], nodes2[2], nodes2[3], nodes2[4]));
       continue;
     }
     if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
@@ -5512,8 +5962,26 @@ function validateDispatchSpec(spec, arity, fallbackRouted) {
   }
 }
 var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
-function ownTableProgram(prog, resolved) {
-  return { ...prog, [TABLE_RUNTIME]: { resolved } };
+function ownTableProgram(prog, resolved, caches = {}) {
+  const runtime = prog[TABLE_RUNTIME];
+  return {
+    ...prog,
+    [TABLE_RUNTIME]: {
+      resolved,
+      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
+      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
+    }
+  };
+}
+function choiceRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
+}
+function choiceCannotCommit(prog, ip) {
+  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
+}
+function failureRollbackClean(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
 }
 var WIDE_CLASS_PREFIX_LO = 65535;
 var WIDE_CLASS_PREFIX_HI = 0;
@@ -5529,22 +5997,22 @@ function validateClassRange(lo, hi) {
 }
 function encodeClassSpec(ranges) {
   let wide = false;
-  for (const range of ranges) {
-    validateClassRange(range.lo, range.hi);
-    if (range.hi > 65535) wide = true;
+  for (const range2 of ranges) {
+    validateClassRange(range2.lo, range2.hi);
+    if (range2.hi > 65535) wide = true;
   }
   if (!wide) {
     let spec2 = "";
-    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
+    for (const range2 of ranges) spec2 += String.fromCharCode(range2.lo, range2.hi);
     return spec2;
   }
   let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
-  for (const range of ranges) {
+  for (const range2 of ranges) {
     spec += String.fromCharCode(
-      range.lo >>> 16,
-      range.lo & 65535,
-      range.hi >>> 16,
-      range.hi & 65535
+      range2.lo >>> 16,
+      range2.lo & 65535,
+      range2.hi >>> 16,
+      range2.hi & 65535
     );
   }
   return spec;
@@ -5688,7 +6156,6 @@ function directArrayProjection(fn, fnSrc, arity) {
 
 // src/table/encode.ts
 import {
-  assertLexicalCapabilityClosure,
   collectLexicalCapabilities,
   winnerWrapsReference as winnerWrapsReference2
 } from "../compiler/token-capability.js";
@@ -6070,6 +6537,25 @@ var Encoder = class {
   lexIndex = /* @__PURE__ */ new Map();
   lexPrograms = [];
   lexProgramIndex = /* @__PURE__ */ new Map();
+  choiceRollbackMasks = /* @__PURE__ */ new Map();
+  nonCommittingChoiceSites = /* @__PURE__ */ new Set();
+  failureRollbackCleanSites = /* @__PURE__ */ new Set();
+  /**
+   * `hasSideWriter` memo for `failureNeedsRollback`, shared across every call
+   * for the lifetime of this `Encoder`. A cached entry is written only when
+   * `complete` is true, which means the answer is a path-independent fact
+   * about that combinator node — it does not depend on which root's traversal
+   * asked, only on the node's own reachable subgraph. Scoping the memo per call
+   * (as a local inside `failureNeedsRollback`) was correct but discarded that
+   * fact after every arm, so a grammar with many ordered-choice arms / optional
+   * / attempt sites re-walked the SAME shared rule graph from scratch for each
+   * site — O(sites × graph size) instead of O(graph size). Measured on the
+   * scss-parser grammar (composed CSS-base superset, the deepest/largest of the
+   * four grammars): 47-50s for one `compileRuleMap` with the per-call memo,
+   * versus the whole macro transform completing in under a second once this
+   * memo is hoisted here.
+   */
+  sideWriterMemo = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -6480,6 +6966,72 @@ var Encoder = class {
     const w = this.winners;
     return w === void 0 ? void 0 : (name) => w[name];
   }
+  /**
+   * Whether a failed ordered-choice arm can leave state that the enclosing
+   * choice must restore before trying its successor.
+   *
+   * `mayLeavePartialCapture` is the existing sound CST/trivia proof. The extra
+   * writer census covers the side sinks that proof deliberately does not model:
+   * fields, recovered errors, and interpreted scanners. Strict assemblies do
+   * not run repeat recovery, but these rows can still publish through a caller's
+   * context. Cycles are safe to stop: revisiting the same combinator cannot
+   * discover a writer the first traversal did not already reach.
+   */
+  failureNeedsRollback(p, autoNot) {
+    const refName = p._ruleName;
+    const winner = refName === void 0 ? void 0 : this.winners?.[refName];
+    const root = winner !== void 0 && !winnerWrapsReference2(winner, p) ? winner : p;
+    const sideWriterMemo = this.sideWriterMemo;
+    const seen = /* @__PURE__ */ new Set();
+    const hasSideWriter = (current) => {
+      const cached = sideWriterMemo.get(current);
+      if (cached !== void 0) return { found: cached, complete: true };
+      if (seen.has(current)) return { found: false, complete: false };
+      seen.add(current);
+      const def = current._def;
+      let result;
+      switch (def.tag) {
+        case "field":
+        case "expect":
+        case "recover":
+        case "scanTo":
+        case "unknown":
+          result = { found: true, complete: true };
+          break;
+        case "lazy": {
+          const name = current._ruleName;
+          const resolvedWinner = name === void 0 ? void 0 : this.winners?.[name];
+          if (resolvedWinner !== void 0 && !winnerWrapsReference2(resolvedWinner, current)) {
+            result = hasSideWriter(resolvedWinner);
+            break;
+          }
+          try {
+            result = hasSideWriter(def.thunk());
+          } catch {
+            result = { found: true, complete: true };
+          }
+          break;
+        }
+        default: {
+          let complete = true;
+          result = { found: false, complete: true };
+          for (const child of childrenOf2(def)) {
+            const childResult = hasSideWriter(child);
+            if (childResult.found) {
+              result = { found: true, complete: true };
+              break;
+            }
+            complete &&= childResult.complete;
+          }
+          if (!result.found) result = { found: false, complete };
+        }
+      }
+      seen.delete(current);
+      if (result.found || result.complete) sideWriterMemo.set(current, result.found);
+      return result;
+    };
+    return mayLeavePartialCapture(root, /* @__PURE__ */ new Set(), true) || hasSideWriter(root).found || (autoNot?.length ?? 0) > 0 && capturesLeaf(root);
+  }
   /** A first set becomes a char class string, or −1 for `any`. */
   charClass(fs3) {
     if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return -1;
@@ -6765,9 +7317,39 @@ var Encoder = class {
         });
         const rr = this.refResolver();
         const finalChoice = classifyFinalChoice(arms, rr);
-        const classes = arms.map((_, i) => finalChoice.nullable[i] ? -1 : this.charClass(finalChoice.firstSets[i]));
+        const transactionalFirst = arms.map((arm, i) => {
+          if (!finalChoice.nullable[i]) return void 0;
+          const def = arm._def;
+          if (def.tag !== "attempt" || matchesEmpty(def.parser, /* @__PURE__ */ new Set(), rr)) return void 0;
+          return firstSetOf(def.parser, /* @__PURE__ */ new Set(), rr);
+        });
+        const gateFirst = finalChoice.firstSets.map((first, i) => transactionalFirst[i] ?? first);
+        const classes = gateFirst.map((first, i) => finalChoice.nullable[i] && transactionalFirst[i] === void 0 ? -1 : this.charClass(first));
+        if (transactionalFirst.some((first) => first !== void 0) && classes.every((cls) => cls >= 0)) {
+          let overlap = false;
+          for (let i = 0; i < gateFirst.length && !overlap; i++) {
+            for (let j = i + 1; j < gateFirst.length; j++) {
+              if (intersects(gateFirst[i], gateFirst[j])) {
+                overlap = true;
+                break;
+              }
+            }
+          }
+          if (!overlap) for (let i = 0; i < classes.length; i++) {
+            if (transactionalFirst[i] !== void 0) classes[i] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
+        let rollbackMask = kids.length > 31 ? -1 : 0;
+        if (rollbackMask === 0) {
+          for (let i = 0; i < arms.length; i++) {
+            const src = order[i];
+            if (this.failureNeedsRollback(arms[i], d.autoNot[src])) {
+              rollbackMask |= 1 << i;
+            }
+          }
+        }
         const head = this.emitHead(OP_CHOICE, 3 + 2 * kids.length);
         this.code[head + 1] = dispIdx;
         this.code[head + 2] = kids.length;
@@ -6776,6 +7358,10 @@ var Encoder = class {
           this.code[head + 4 + i] = kids[i];
           this.code[head + 4 + kids.length + i] = this.expected(deriveExpected(arms[i]));
         }
+        this.choiceRollbackMasks.set(head, rollbackMask);
+        if (arms.every((arm) => !mayCommitFailure(arm, /* @__PURE__ */ new Set(), rr))) {
+          this.nonCommittingChoiceSites.add(head);
+        }
         return head;
       }
       case "many":
@@ -6805,8 +7391,11 @@ var Encoder = class {
         }
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, flags);
       }
-      case "optional":
-        return this.emit(OP_OPT, this.node(d.parser).ip);
+      case "optional": {
+        const head = this.emit(OP_OPT, this.node(d.parser).ip);
+        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
+        return head;
+      }
       case "transform": {
         const inner = d.parser._def;
         if (inner.tag === "sequence" && !this.memo.has(d.parser) && !this.pending.has(d.parser)) {
@@ -6965,6 +7554,7 @@ var Encoder = class {
       // lowering was correct only for a choice arm.
       case "attempt": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip);
+        if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
         const fs3 = d.parser._meta.firstSet;
         if (fs3.kind === "any" || matchesEmpty(d.parser)) return inner;
         const cls = this.charClass(fs3);
@@ -7133,6 +7723,10 @@ var Encoder = class {
       ...this.rec ? { rec: 1 } : {},
       ...this.cov === void 0 ? {} : { cov: this.cov },
       lines: this.track ? 1 : 0
+    }, void 0, {
+      choiceRollbackMasks: this.choiceRollbackMasks,
+      failureRollbackCleanSites: this.failureRollbackCleanSites,
+      nonCommittingChoiceSites: this.nonCommittingChoiceSites
     });
   }
 };
@@ -7177,7 +7771,6 @@ function encodeTableProgram(ruleMap, settings = {}) {
   const lexicalRoots = [...names].sort().map((name) => ruleMap[name]);
   const resolveLexical = (name) => ruleMap[name];
   const capabilities = collectLexicalCapabilities(lexicalRoots, resolveLexical);
-  assertLexicalCapabilityClosure(lexicalRoots, capabilities, resolveLexical);
   const enc = new Encoder(resolvedSettings, capabilities.capabilityComplete);
   enc.winners = ruleMap;
   for (const name of names) enc.encodeRule(name, ruleMap[name]);
@@ -8310,13 +8903,17 @@ var TRI_NONE = -1;
 var CAP_UNKNOWN = 0;
 var CAP_OFF = 1;
 var CAP_ON = 2;
-var TOP = { tri: TRI_UNKNOWN, buf: false, cap: CAP_UNKNOWN };
+var RAW_UNKNOWN = 0;
+var RAW_CAPTURE = 1;
+var RAW_OMIT = 2;
+var TOP = { tri: TRI_UNKNOWN, buf: false, raw: RAW_UNKNOWN, cap: CAP_UNKNOWN };
 function meet(a, b) {
   const tri = a.tri === b.tri ? a.tri : TRI_UNKNOWN;
   const buf = a.buf && b.buf;
+  const raw = a.raw === b.raw ? a.raw : RAW_UNKNOWN;
   const cap = a.cap === b.cap ? a.cap : CAP_UNKNOWN;
-  if (tri === a.tri && buf === a.buf && cap === a.cap) return a;
-  return { tri, buf, cap };
+  if (tri === a.tri && buf === a.buf && raw === a.raw && cap === a.cap) return a;
+  return { tri, buf, raw, cap };
 }
 function reachableSites(code, roots) {
   const seen = /* @__PURE__ */ new Set();
@@ -8339,25 +8936,26 @@ function transfer(code, ip, at, hostCst) {
     const tri = ki < 0 ? TRI_NONE : ki;
     const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
     if (tri === at.tri && cap === at.cap) return at;
-    return { tri, buf: at.buf, cap };
+    return { tri, buf: at.buf, raw: at.raw, cap };
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
     const flags = code[ip + 3];
     const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags === 2 || flags === 18 || flags === 34);
     if (directChildren) {
-      return { tri: at.tri, buf: false, cap: CAP_OFF };
+      return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
     }
     const cap = (flags & 4) !== 0 || hostCst ? CAP_ON : CAP_OFF;
-    if (at.buf && cap === at.cap) return at;
-    return { tri: at.tri, buf: true, cap };
+    const raw = !hostCst && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags & 2) !== 0 ? RAW_OMIT : RAW_CAPTURE;
+    if (at.buf && raw === at.raw && cap === at.cap) return at;
+    return { tri: at.tri, buf: true, raw, cap };
   }
   if (op === OP_TOKEN) {
     if (at.tri === TRI_NONE && !at.buf) return at;
-    return { tri: TRI_NONE, buf: false, cap: at.cap };
+    return { tri: TRI_NONE, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
   }
   if (op === OP_LEAF) {
     if (!at.buf) return at;
-    return { tri: at.tri, buf: false, cap: at.cap };
+    return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: at.cap };
   }
   return at;
 }
@@ -8424,6 +9022,162 @@ function scalarTerminalNotChild(code, ip) {
   const op = code[child];
   return op === OP_RX || op === OP_LIT ? child : -1;
 }
+function leadingScalarTerminal(code, ip, minDepth = 2, throughAttempt = true, throughPeek = false) {
+  const seen = /* @__PURE__ */ new Set();
+  let at = ip;
+  let depth = 0;
+  while (!seen.has(at)) {
+    seen.add(at);
+    const op = code[at];
+    if (op === OP_LIT || op === OP_RX) return depth >= minDepth ? at : -1;
+    if (op === OP_RULE || op === OP_LABEL || op === OP_TOKEN || throughAttempt && op === OP_ATTEMPT) {
+      at = code[at + 1];
+      depth++;
+      continue;
+    }
+    if (throughPeek && op === OP_PEEK) {
+      at = code[at + 1];
+      depth++;
+      continue;
+    }
+    if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+      at = code[at + 2];
+      depth++;
+      continue;
+    }
+    if (op === OP_SEQ || op === OP_SEQV) {
+      if (code[at + 1] < 1) return -1;
+      at = code[at + 2];
+      depth++;
+      continue;
+    }
+    if (op === OP_SEQX) {
+      if (code[at + 2] < 1) return -1;
+      at = code[at + 3];
+      depth++;
+      continue;
+    }
+    return -1;
+  }
+  return -1;
+}
+function leadingScalarSequence(code, ip) {
+  const wholeScalar = (start) => {
+    const seen2 = /* @__PURE__ */ new Set();
+    let at2 = start;
+    while (!seen2.has(at2)) {
+      seen2.add(at2);
+      const op = code[at2];
+      if (op === OP_LIT || op === OP_RX) return at2;
+      if (op === OP_RULE || op === OP_TOKEN || op === OP_ATTEMPT) {
+        at2 = code[at2 + 1];
+        continue;
+      }
+      if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+        at2 = code[at2 + 2];
+        continue;
+      }
+      if (op === OP_SEQ || op === OP_SEQV) {
+        if (code[at2 + 1] !== 1) return -1;
+        at2 = code[at2 + 2];
+        continue;
+      }
+      if (op === OP_SEQX) {
+        if (code[at2 + 2] !== 1) return -1;
+        at2 = code[at2 + 3];
+        continue;
+      }
+      return -1;
+    }
+    return -1;
+  };
+  const seen = /* @__PURE__ */ new Set();
+  let at = ip;
+  let ambientTrivia;
+  while (!seen.has(at)) {
+    seen.add(at);
+    const op = code[at];
+    if (op === OP_RULE) {
+      at = code[at + 1];
+      continue;
+    }
+    if (op === OP_SCOPE_PLAIN) {
+      ambientTrivia = code[at + 1];
+      at = code[at + 2];
+      continue;
+    }
+    if (op === OP_GATE || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+      at = code[at + 2];
+      continue;
+    }
+    const n = op === OP_SEQ || op === OP_SEQV ? code[at + 1] : op === OP_SEQX ? code[at + 2] : 0;
+    if (n < 3 || ambientTrivia === void 0) return void 0;
+    const base = op === OP_SEQX ? at + 3 : at + 2;
+    const terminals = [
+      wholeScalar(code[base]),
+      wholeScalar(code[base + 1]),
+      wholeScalar(code[base + 2])
+    ];
+    return terminals.every((terminal) => terminal >= 0) ? { terminals, trivia: ambientTrivia } : void 0;
+  }
+  return void 0;
+}
+function leadingLiteralFamily(code, constants, ip, minDepth = 2, limit = 4) {
+  const active = /* @__PURE__ */ new Set();
+  const walk = (at, depth) => {
+    if (active.has(at)) return void 0;
+    active.add(at);
+    try {
+      const op = code[at];
+      if (op === OP_LIT) {
+        const value = constants[code[at + 1]];
+        return depth >= minDepth && typeof value === "string" && value.length > 0 ? [at] : void 0;
+      }
+      if (op === OP_RULE || op === OP_LABEL || op === OP_TOKEN || op === OP_ATTEMPT || op === OP_PEEK) {
+        return walk(code[at + 1], depth + 1);
+      }
+      if (op === OP_GATE || op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN || op === OP_XFORM || op === OP_NODE || op === OP_FIELD || op === OP_LEAF) {
+        return walk(code[at + 2], depth + 1);
+      }
+      if (op === OP_SEQ || op === OP_SEQV) {
+        return code[at + 1] < 1 ? void 0 : walk(code[at + 2], depth + 1);
+      }
+      if (op === OP_SEQX) {
+        return code[at + 2] < 1 ? void 0 : walk(code[at + 3], depth + 1);
+      }
+      if (op !== OP_CHOICE) return void 0;
+      const n = code[at + 2];
+      if (n < 1) return void 0;
+      const out = [];
+      for (let i = 0; i < n; i++) {
+        const branch = walk(code[at + 4 + i], depth + 1);
+        if (branch === void 0) return void 0;
+        for (const terminal of branch) {
+          const value = constants[code[terminal + 1]];
+          let covered = false;
+          for (let j = 0; j < out.length; j++) {
+            const prior = constants[code[out[j] + 1]];
+            if (value.startsWith(prior)) {
+              covered = true;
+              break;
+            }
+          }
+          if (covered) continue;
+          for (let j = out.length - 1; j >= 0; j--) {
+            const prior = constants[code[out[j] + 1]];
+            if (prior.startsWith(value)) out.splice(j, 1);
+          }
+          out.push(terminal);
+          if (out.length > limit) return void 0;
+        }
+      }
+      return out;
+    } finally {
+      active.delete(at);
+    }
+  };
+  return walk(ip, 0);
+}
 
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
@@ -8505,6 +9259,16 @@ let _pfScan=null
 let _pfHost
 let _pfDepth=0
 const _pfFrames=[]
+let _pfTokInput
+let _pfTokPos=-1
+let _pfTokBody=-1
+let _pfTokPacked=-1
+let _pfTokValue
+let _pfTokDispatch=-1
+let _pfTokArm=-1
+let _pfTokEnd=-1
+let _pfSeqEnd=-1
+function _asciiFoldCode(c){return c>=65&&c<=90?c+32:c}
 function _skipTrivia(input,cur,ctx){
 const s=_pfScan
 if(s!==null&&ctx._triviaLog===undefined&&!(ctx.captureTrivia===true&&(ctx._cstBuf!==undefined||ctx._cstTriviaLog!==undefined)))return s(input,cur)
@@ -8570,6 +9334,40 @@ if(ctx._triviaLog!==undefined&&ctx._triviaLog.length!==lg)ctx._triviaLog.length=
 if(ctx._rootTriviaLog!==undefined&&ctx._rootTriviaLog.length!==rt)ctx._rootTriviaLog.length=rt
 }
 `;
+var NO_RAW_RUNTIME_PRELUDE = `
+function _pushLeafNoRawBuf(ctx,value,s,e){
+const l={_tag:'leaf',value,span:{start:s,end:e}}
+const b=ctx._cstBuf
+if(b.ch!==undefined)b.ch.push(l)
+else if(b.single!==undefined){b.ch=[b.single,l];b.single=undefined}
+else b.single=l
+b.rawLen++
+}
+function _pushNodeNoRawBuf(ctx,value){
+const b=ctx._cstBuf
+if(b.ch!==undefined)b.ch.push(value)
+else if(b.single!==undefined){b.ch=[b.single,value];b.single=undefined}
+else b.single=value
+b.rawLen++
+}
+function _rbNoRawBuf(ctx,raw,tl,lv,lg,rt){
+const b=ctx._cstBuf
+if(b.rawLen!==raw)b.rawLen=raw
+const ch=b.ch
+if(ch!==undefined){
+if(lv===0)b.ch=undefined
+else if(lv===1){b.single=ch[0];b.ch=undefined}
+else if(ch.length!==lv)ch.length=lv
+}else if(lv===0)b.single=undefined
+const bt=b.tl
+if(bt!==undefined){
+if(tl===0)b.tl=undefined
+else if(bt.length!==tl)bt.length=tl
+}
+if(ctx._triviaLog!==undefined&&ctx._triviaLog.length!==lg)ctx._triviaLog.length=lg
+if(ctx._rootTriviaLog!==undefined&&ctx._rootTriviaLog.length!==rt)ctx._rootTriviaLog.length=rt
+}
+`;
 function q(s) {
   return JSON.stringify(s);
 }
@@ -8582,11 +9380,12 @@ function sinkReads(t, s) {
 ${t}fd=ctx._fields!==undefined?ctx._fields.length:0` : ""}${s.er ? `
 ${t}er=ctx._errors!==undefined?ctx._errors.length:0` : ""}`;
 }
-function emitMark(t, buf, s = NO_SINKS, decl = true) {
+function emitMark(t, buf, rawMode, s = NO_SINKS, decl = true) {
   if (buf) {
+    const raw = rawMode === RAW_OMIT ? `${t}raw=b.rawLen` : rawMode === RAW_CAPTURE ? `const r=b.raw;${t}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0` : `const r=b.raw;${t}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)`;
     return `${decl ? `let ${t}raw=0,${t}tl=0,${t}lv=0,${t}lg=0,${t}rt=0${sinkSlots(t, s)}
 ` : ""}{const b=ctx._cstBuf
-const r=b.raw;${t}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+${raw}
 const h=b.ch;${t}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${t}tl=l!==undefined?l.length:0
 ${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
@@ -8596,7 +9395,7 @@ ${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t,
 ` : `${t}n=false
 `}{const b=ctx._cstBuf
 if(b!==undefined){
-const r=b.raw;${t}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const r=b.raw;${t}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)
 const h=b.ch;${t}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${t}tl=l!==undefined?l.length:0
 ${t}n=true
@@ -8611,14 +9410,16 @@ ${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t, s)}
 }}`;
 }
-function emitRollback(t, buf, s = NO_SINKS) {
+function emitRollback(t, buf, rawMode, s = NO_SINKS) {
   const fd = s.fd ? `
 if(ctx._fields!==undefined&&ctx._fields.length!==${t}fd)ctx._fields.length=${t}fd` : "";
   const er = s.er ? `
 if(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}er` : "";
-  if (buf) return `_rbBuf(ctx,${t}raw,${t}tl,${t}lv,${t}lg,${t}rt)${fd}${er}`;
-  if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,0,undefined,${t}lg,${t}rt)`;
-  return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "0"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
+  if (buf && rawMode === RAW_OMIT) return `_rbNoRawBuf(ctx,${t}raw,${t}tl,${t}lv,${t}lg,${t}rt)${fd}${er}`;
+  if (buf && rawMode === RAW_CAPTURE) return `_rbBuf(ctx,${t}raw,${t}tl,${t}lv,${t}lg,${t}rt)${fd}${er}`;
+  if (buf) return `rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "undefined"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)`;
+  if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,undefined,undefined,${t}lg,${t}rt)`;
+  return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "undefined"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
 }
 function emitTerm(callee, dst, t, l, skip) {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
@@ -8676,37 +9477,111 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t, prog, cfg, extraIps = []) {
-  const { code, k, disp, dsp, triviaLabelled } = t;
+function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
+  const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
+  const reachable = [...reachableSites(code, roots)];
   const labels = computeSiteLabels(code, roots, hostCst);
   const scalarSpecs = /* @__PURE__ */ new Set();
+  const largeChoiceScalarSpecs = /* @__PURE__ */ new Set();
+  const largeChoiceLiteralFamilies = /* @__PURE__ */ new Map();
+  const largeChoiceScalarSequences = /* @__PURE__ */ new Map();
+  const tokenChoiceCandidates = /* @__PURE__ */ new Map();
+  const tokenChoiceDispatches = /* @__PURE__ */ new Set();
+  const tokenChoiceBodies = /* @__PURE__ */ new Set();
   if (!hostCst && !cfg.tolerant && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
-    for (const ip of reachableSites(code, roots)) {
-      if (code[ip] !== OP_NODE) continue;
-      const child = scalarTerminalNodeChild(code, ip);
-      if (child >= 0) scalarSpecs.add(code[child + 1]);
+    for (const ip of reachable) {
+      if (code[ip] === OP_NODE) {
+        const child = scalarTerminalNodeChild(code, ip);
+        if (child >= 0) scalarSpecs.add(code[child + 1]);
+        continue;
+      }
+      if (code[ip] !== OP_CHOICE || disp[code[ip + 1]].exclusive) continue;
+      const n = code[ip + 2];
+      for (let i = 0; i < n; i++) {
+        const armIp = code[ip + 4 + i];
+        const child = leadingScalarTerminal(code, armIp, 2, true, true);
+        if (n === 2 || n === 3) {
+          if (child >= 0) scalarSpecs.add(code[child + 1]);
+          continue;
+        }
+        if (child >= 0) {
+          const spec = k[code[child + 1]];
+          if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
+            largeChoiceScalarSpecs.add(code[child + 1]);
+            continue;
+          }
+        }
+        const family = leadingLiteralFamily(code, k, armIp);
+        if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
+          const value = k[code[terminal + 1]];
+          return typeof value === "string" && value.length >= 2;
+        })) {
+          largeChoiceLiteralFamilies.set(armIp, family);
+        }
+        const sequence6 = leadingScalarSequence(code, armIp);
+        if (sequence6 !== void 0 && (sequence6.trivia < 0 || swapLegal && t.triviaScan[sequence6.trivia] != null)) {
+          largeChoiceScalarSequences.set(armIp, sequence6);
+        }
+      }
+      let candidate;
+      let ambiguous = false;
+      for (let i = 0; i < n; i++) {
+        const armIp = code[ip + 4 + i];
+        if (code[armIp] !== OP_XFORM) continue;
+        const dispatchIp = code[armIp + 2];
+        if (code[dispatchIp] !== OP_DISPATCH) continue;
+        const selectorIp = code[dispatchIp + 1];
+        if (code[selectorIp] !== OP_LEX_BODY) continue;
+        if (candidate !== void 0) {
+          ambiguous = true;
+          break;
+        }
+        candidate = { arm: i, dispatchIp };
+      }
+      if (!ambiguous && candidate !== void 0) {
+        tokenChoiceCandidates.set(ip, candidate);
+        tokenChoiceDispatches.add(candidate.dispatchIp);
+        tokenChoiceBodies.add(code[code[candidate.dispatchIp + 1] + 1]);
+      }
     }
   }
-  const sinks = (() => {
-    let fd = false;
-    let er = REC2;
-    for (const ip of reachableSites(code, roots)) {
-      const op = code[ip];
-      if (op === OP_SCAN) {
-        fd = true;
-        er = true;
-        break;
+  const needsNoRawPrelude = !hostCst && reachable.some((ip) => {
+    const op = code[ip];
+    return (op === OP_NODE || op === OP_NODE_TRACK) && code[ip + 1] >= 0 && code[ip + 4] < 0 && (code[ip + 3] & 2) !== 0;
+  });
+  const sinkSites = reachable;
+  const sinkBits = /* @__PURE__ */ new Map();
+  for (const ip of sinkSites) {
+    const op = code[ip];
+    sinkBits.set(
+      ip,
+      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC2 && (op === OP_REP || op === OP_REPV) ? 2 : 0)
+    );
+  }
+  const sinkKids = [];
+  let sinkChanged = true;
+  while (sinkChanged) {
+    sinkChanged = false;
+    for (const ip of sinkSites) {
+      let bits = sinkBits.get(ip) ?? 0;
+      sinkKids.length = 0;
+      childSlots(code, ip, sinkKids);
+      for (let i = 0; i < sinkKids.length; i++) bits |= sinkBits.get(sinkKids[i]) ?? 0;
+      if (bits !== sinkBits.get(ip)) {
+        sinkBits.set(ip, bits);
+        sinkChanged = true;
       }
-      if (op === OP_FIELD) fd = true;
-      else if (op === OP_EXPECT) er = true;
     }
-    return { fd, er };
-  })();
+  }
+  const sinksAt = (ip) => {
+    const bits = sinkBits.get(ip) ?? 0;
+    return bits === 0 ? NO_SINKS : { fd: (bits & 1) !== 0, er: (bits & 2) !== 0 };
+  };
   const bodies = [];
   const byIp = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
@@ -8733,9 +9608,117 @@ function emitAssemblySource(t, prog, cfg, extraIps = []) {
   const fxRef = (i) => hoist("fx", `FX[${i}]`);
   const fnRef = (i) => hoist("fn", `FNS[${i}]`);
   const recognizerRef = (i) => hoist("rec", `RECOG[${i}]`);
+  const scalarSequenceRefs = /* @__PURE__ */ new Map();
+  const scalarSequenceRef = (sequence6) => {
+    const key = `${sequence6.trivia}:${sequence6.terminals.map((terminal) => code[terminal + 1]).join(",")}`;
+    const prior = scalarSequenceRefs.get(key);
+    if (prior !== void 0) return prior;
+    const recognizers = sequence6.terminals.map((terminal) => recognizerRef(code[terminal + 1]));
+    const expected = sequence6.terminals.map((terminal) => fxRef(code[terminal + 2]));
+    const scan = sequence6.trivia < 0 ? void 0 : hoist("ts", `TRIVIASCAN[${sequence6.trivia}]`);
+    const name = `_sd${scalarSequenceRefs.size}_`;
+    const steps = recognizers.map((recognize, i) => `${i === 0 ? "let " : ""}at=${i === 0 ? "pos" : scan === void 0 ? "cur" : `${scan}(input,cur)`}
+${i === 0 ? "let " : ""}cur=${recognize}(input,at)
+if(cur<0){_pfSeqEnd=at;return ${~i}}`).join("\n");
+    choiceDefs.push(`function ${name}(input,pos){
+${steps}
+return cur
+}`);
+    const made = { name, expected };
+    scalarSequenceRefs.set(key, made);
+    return made;
+  };
   const sentRef = (cls) => cls < 0 ? "undefined" : hoist("sent", `SENTS[${cls}]`);
   let uid = 0;
   const tmp = () => `_t${uid++}_`;
+  const dispatchClaim = (m) => {
+    switch (m[0]) {
+      case 0:
+        return `key.startsWith(${q(m[1])})`;
+      case 1:
+        return `key.endsWith(${q(m[1])})`;
+      case 3:
+        return `asciiFoldKey(key).startsWith(${q(m[1])})`;
+      case 4:
+        return `asciiFoldKey(key).endsWith(${q(m[1])})`;
+      default: {
+        if (!m[2].includes("g") && !m[2].includes("y")) {
+          try {
+            new RegExp(m[1], m[2]);
+            return `${hoist("dm", `new RegExp(${q(m[1])},${q(m[2])})`)}.test(key)`;
+          } catch {
+          }
+        }
+        return `new RegExp(${q(m[1])},${q(m[2])}).test(key)`;
+      }
+    }
+  };
+  const tokenDecisionRefs = /* @__PURE__ */ new Map();
+  function tokenDecisionFor(dispatchIp) {
+    const prior = tokenDecisionRefs.get(dispatchIp);
+    if (prior !== void 0) return prior;
+    const selectorIp = code[dispatchIp + 1];
+    const body = code[selectorIp + 1];
+    const lineFlags = code[selectorIp + 4];
+    const hasSuffix = (lineFlags & 4) !== 0;
+    const di = code[dispatchIp + 2];
+    const spec = dsp[di];
+    const n = code[dispatchIp + 5];
+    validateDispatchSpec(spec, n, code[dispatchIp + 4]);
+    const recognize = hoist("lex", `LEX[${body}]`);
+    const bk = hoist("bk", `DSP[${di}].byKey`);
+    const expected = hoist("dx", `DSP[${di}].expected`);
+    const fold = spec.byFold.size > 0 ? `if(arm===undefined)arm=${hoist("bf", `DSP[${di}].byFold`)}.get(asciiFoldKey(key))
+` : "";
+    const chain = spec.match.length === 0 ? "" : `if(arm===undefined){
+${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${dispatchClaim(m)})arm=${m[3]}`).join("\n")}
+}
+`;
+    const foldedEntries = [...spec.byFold.entries()];
+    const fixedFunctionChoice = spec.byKey.size === 0 && foldedEntries.length === 1 && spec.match.length === 1 && spec.match[0][0] === 2 && spec.match[0][1] === "^(?!(?:url|calc)\\($).+\\($" && spec.match[0][2] === "i" && code[dispatchIp + 3] < 0;
+    const foldedRangeEquals = (value) => {
+      const folded = value.replace(/[A-Z]/g, (c) => c.toLowerCase());
+      return `e-pos===${folded.length}&&${[...folded].map((c, i) => {
+        const cc = c.charCodeAt(0);
+        return `_asciiFoldCode(input.charCodeAt(pos+${i}))===${cc}`;
+      }).join("&&")}`;
+    };
+    const classify = fixedFunctionChoice ? (() => {
+      const [exact, exactArm] = foldedEntries[0];
+      const genericArm = spec.match[0][3];
+      return `let arm
+if(${foldedRangeEquals(exact)})arm=${exactArm}
+else if(sm&&e>pos+1){
+let clean=true
+for(let i=pos;i<e;i++){const c=input.charCodeAt(i);if(c===10||c===13||c===0x2028||c===0x2029){clean=false;break}}
+if(clean&&!(${foldedRangeEquals("url(")})&&!(${foldedRangeEquals("calc(")}))arm=${genericArm}
+}`;
+    })() : `const key=input.slice(pos,e)
+let arm=${bk}.get(key)
+${fold}${chain}`;
+    const name = `_td${tokenDecisionRefs.size}_`;
+    choiceDefs.push(`function ${name}(input,pos){
+const r=${recognize}(input,pos)
+if(r<0)return -1
+const sm=${hasSuffix ? "r%2===1" : "false"},e=(r-(sm?1:0))/2
+${classify}
+if(arm===undefined){
+${code[dispatchIp + 3] < 0 ? "_pfTokEnd=e;return 0" : `arm=${n}`}
+}
+${fixedFunctionChoice ? "const key=input.slice(pos,e)" : ""}
+_pfTokInput=input
+_pfTokPos=pos
+_pfTokBody=${body}
+_pfTokPacked=r
+_pfTokValue=key
+_pfTokDispatch=${dispatchIp}
+_pfTokArm=arm
+return 1
+}`);
+    const made = { name, expected };
+    tokenDecisionRefs.set(dispatchIp, made);
+    return made;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -8823,7 +9806,8 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const op = code[ip];
     const head = `function ${fname}(input,pos,ctx){`;
     const L = labels.at(ip);
-    const pushLeaf = L.buf && !cfg.trackLines ? "_pushLeafBuf" : "_pushLeaf";
+    const sinks = sinksAt(ip);
+    const pushLeaf = L.buf && !cfg.trackLines ? L.raw === RAW_OMIT ? "_pushLeafNoRawBuf" : L.raw === RAW_CAPTURE ? "_pushLeafBuf" : "_pushLeaf" : "_pushLeaf";
     const captureLeaf = (value) => {
       const call = `${pushLeaf}(ctx,${value},pos,e)`;
       return L.buf ? call : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${call}`;
@@ -8987,12 +9971,12 @@ return err
       }
       case OP_ROUTED: {
         const fb = code[ip + 1];
-        const fallback = fb >= 0 ? link(fb) : void 0;
+        const fallback2 = fb >= 0 ? link(fb) : void 0;
         const push = `pushCstLeaf(ctx,{_tag:'leaf',value:it.value,span:it.span})`;
         return `${head}
 const it=ctx._routed
 if(it===undefined||pos!==it.span.start){
-${fallback !== void 0 ? `return ${fallback}(input,pos,ctx)` : "ctx._fe=pos;ctx._fx=ROUTED_FX;return FAIL"}
+${fallback2 !== void 0 ? `return ${fallback2}(input,pos,ctx)` : "ctx._fe=pos;ctx._fx=ROUTED_FX;return FAIL"}
 }
 ${L.buf ? push : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${push}`}
 EC.e=it.span.end
@@ -9074,20 +10058,24 @@ return out
 }`;
       }
       case OP_LEX_BODY: {
-        const recognize = hoist("lex", `LEX[${code[ip + 1]}]`);
+        const body = code[ip + 1];
+        const recognize = hoist("lex", `LEX[${body}]`);
         const expected = fxRef(code[ip + 2]);
         const suffixExpected = fxRef(code[ip + 3]);
         const lineFlags = code[ip + 4];
         const hasSuffix = (lineFlags & 4) !== 0;
+        const pending = tokenChoiceBodies.has(body);
         return `${head}
-const r=${recognize}(input,pos)
+${pending ? `const tp=_pfTokBody===${body}&&_pfTokInput===input&&_pfTokPos===pos
+const r=tp?_pfTokPacked:${recognize}(input,pos)` : `const r=${recognize}(input,pos)`}
 if(r<0){ctx._fe=pos;ctx._fx=${expected};if(ctx._probe!==undefined)failAt(ctx,${expected},pos);return FAIL}
 const sm=${hasSuffix ? "r%2===1" : "false"},e=(r-(sm?1:0))/2
 ${(lineFlags & 1) !== 0 ? "_trackLines(ctx,input,sm?e-1:e)" : ""}
 ${hasSuffix ? "ctx._fc=false" : ""}
 ${hasSuffix && (lineFlags & 2) !== 0 ? "if(sm)_trackLines(ctx,input,e)" : ""}
 ${hasSuffix ? `if(!sm){ctx._fe=e;ctx._fx=${suffixExpected};if(ctx._probe!==undefined)failAt(ctx,${suffixExpected},e)}` : ""}
-const v=input.slice(pos,e)
+const v=${pending ? "tp?_pfTokValue:" : ""}input.slice(pos,e)
+${pending ? "if(tp){_pfTokBody=-1;_pfTokValue=undefined}" : ""}
 if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
 EC.e=e
 return v
@@ -9143,12 +10131,13 @@ return v
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, sinks)}
+${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 if(v!==FAIL)return v
-${emitRollback(p, L.buf, sinks)}
+${clean ? "" : emitRollback(p, L.buf, L.raw, sinks)}
 if(ctx._fc===true)return FAIL
 ctx._fe=pos
 return FAIL
@@ -9171,9 +10160,9 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, sinks)}
+${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
-${emitRollback(p, L.buf, sinks)}
+${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
@@ -9185,9 +10174,9 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, sinks)}
+${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
-${emitRollback(p, L.buf, sinks)}
+${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
@@ -9195,14 +10184,15 @@ return null
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, sinks)}
+${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
 if(ctx._fc===true)return FAIL
-${emitRollback(p, L.buf, sinks)}
+${clean ? "" : emitRollback(p, L.buf, L.raw, sinks)}
 EC.e=pos
 return null
 }
@@ -9301,57 +10291,193 @@ return FAIL
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]));
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null);
           const gateRefs = Array.from({ length: n }, (_, i) => hoist("g", `DISP[${di}].armCls[${i}]`));
+          const tokenCandidate = tokenChoiceCandidates.get(ip);
+          const pretests = Array.from({ length: n }, (_, i) => {
+            if (tokenCandidate?.arm === i) {
+              return { token: tokenDecisionFor(tokenCandidate.dispatchIp) };
+            }
+            const terminal = leadingScalarTerminal(code, code[base + i], 2, true, true);
+            if (terminal >= 0) {
+              const spec = code[terminal + 1];
+              if ((n === 2 || n === 3 ? scalarSpecs : largeChoiceScalarSpecs).has(spec)) {
+                return { scalar: [recognizerRef(spec)] };
+              }
+            }
+            const family = largeChoiceLiteralFamilies.get(code[base + i]);
+            if (family !== void 0) {
+              return { scalar: family.map((member) => recognizerRef(code[member + 1])) };
+            }
+            const sequence6 = largeChoiceScalarSequences.get(code[base + i]);
+            return sequence6 === void 0 ? void 0 : { sequence: scalarSequenceRef(sequence6) };
+          });
           const maskable = n <= 32;
           const maskName = maskable ? hoist("mk", `MASK[${masks.push(maskForClassRow(gates)) - 1}]`) : "";
           if (maskable) maskPlan.push(~di);
           const p = tmp();
-          const catchName = maskable ? `_cx${uid++}_` : "";
-          if (maskable) {
+          const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
+          const rollbackMask = REC2 ? -1 : encodedRollbackMask;
+          const hasRollback = rollbackMask !== 0;
+          const startFailureExact = arms.every((_arm, i) => {
+            const terminal = leadingScalarTerminal(code, code[base + i], 0, false);
+            if (terminal < 0) return false;
+            const op2 = code[terminal];
+            const spec = k[code[terminal + 1]];
+            const terminalFx = fx[code[terminal + 2]];
+            const armFx = fx[code[base + n + i]];
+            if (terminalFx.length !== armFx.length || terminalFx.some((expected2, at) => expected2 !== armFx[at])) return false;
+            if (op2 === OP_LIT) return typeof spec === "string" && spec.length > 0;
+            return op2 === OP_RX && spec instanceof RegExp && !regexCanMatchEmpty(spec.source);
+          });
+          const rollbackFor = (i) => rollbackMask === -1 || (rollbackMask & 1 << i) !== 0 ? emitRollback(p, L.buf, L.raw, sinks) : "";
+          if (choiceCannotCommit(prog, ip) && !startFailureExact) {
+            const deepAt = Array.from({ length: n }, () => tmp());
+            const deepFx = Array.from({ length: n }, () => tmp());
+            const remember = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
+            const lazyArms = (ascii) => arms.map((arm, i) => {
+              const pretest = pretests[i];
+              const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
+              const scalarCondition = pretest?.scalar === void 0 ? "" : pretest.scalar.length === 1 ? `&&${pretest.scalar[0]}(input,pos)>=0` : `&&(${pretest.scalar.map((recognize) => `${recognize}(input,pos)>=0`).join("||")})`;
+              const sequenceCondition = pretest?.sequence === void 0 ? "" : `&&(${decision}=${pretest.sequence.name}(input,pos))>=0`;
+              const condition = pretest?.token !== void 0 ? `&&(${decision}=${pretest.token.name}(input,pos))>0` : scalarCondition || sequenceCondition;
+              const gate2 = ascii ? `(bits&${1 << i})!==0${condition}` : `(${gateRefs[i]}===null||classHas(${gateRefs[i]},c))${condition}`;
+              const routeMiss = pretest?.token === void 0 ? "" : `
+if(${decision}===0){
+ctx._fc=false
+{const at=_pfTokEnd
+${remember(i, "at", pretest.token.expected)}}
+}`;
+              const sequenceMiss = pretest?.sequence === void 0 ? "" : `
+else if(${ascii ? `(bits&${1 << i})!==0&&` : ""}${decision}<0){
+ctx._fc=false
+{const at=_pfSeqEnd
+${remember(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
+}`;
+              return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
+`}if(${gate2}){
+ctx._fc=false
+{const v=${arm}(input,pos,ctx)
+if(v!==FAIL)return v}
+{const at=ctx._fe??pos
+${remember(i, "at", "ctx._fx")}}
+${rollbackFor(i)}
+}${routeMiss}${sequenceMiss}`;
+            }).join("\n");
+            const merge = deepAt.map((at, i) => `{const at=${at}??pos
+const ex=${at}===undefined?${expected[i]}:${deepFx[i]}
+if(at>best){best=at;acc=_accSet(ex,undefined)}
+else if(at===best)acc=_accSet(ex,acc)
+}`).join("\n");
+            const finish = `let best=pos,acc
+${merge}
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
+return FAIL`;
+            return `${head}
+const c=lead(input,pos)
+${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
+${deepAt.map((at, i) => `let ${at},${deepFx[i]}`).join("\n")}
+${maskable ? `if(c<128){
+const bits=${maskName}[c<0?128:c]
+if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
+${lazyArms(true)}
+}else{
+${lazyArms(false)}
+}
+` : lazyArms(false)}
+${finish}
+}`;
+          }
+          const needsCatch = maskable || startFailureExact;
+          const catchName = needsCatch ? `_cx${uid++}_` : "";
+          if (needsCatch) {
             const catchCases = expected.map((e, i) => `case ${i}:if(target<=${i})return acc;acc=_accSet(${e},acc)`).join("\n");
             choiceDefs.push(`function ${catchName}(target,prev,acc){switch(prev){
 ${catchCases}
 }return acc}`);
           }
           const maskArms = maskable ? arms.map((arm, i) => {
-            return `if((bits&${1 << i})!==0){
+            const pretest = pretests[i];
+            const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
+            const scalarCondition = pretest?.scalar === void 0 ? "" : pretest.scalar.length === 1 ? `&&${pretest.scalar[0]}(input,pos)>=0` : `&&(${pretest.scalar.map((recognize) => `${recognize}(input,pos)>=0`).join("||")})`;
+            const sequenceCondition = pretest?.sequence === void 0 ? "" : `&&(${decision}=${pretest.sequence.name}(input,pos))>=0`;
+            const condition = pretest?.token !== void 0 ? `&&(${decision}=${pretest.token.name}(input,pos))>0` : scalarCondition || sequenceCondition;
+            const routeMiss = pretest?.token === void 0 ? "" : `
+if(${decision}===0){
+ctx._fc=false
+${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${i},prev,acc)
+prev=${i + 1}`}
+{const at=_pfTokEnd
+if(at>best){best=at;acc=undefined}
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.token.expected},acc)}
+}`;
+            const sequenceMiss = pretest?.sequence === void 0 ? "" : `
+else if((bits&${1 << i})!==0&&${decision}<0){
+ctx._fc=false
+${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${i},prev,acc)
+prev=${i + 1}`}
+{const at=_pfSeqEnd
+if(at>best){best=at;acc=undefined}
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("")}${pretest.sequence.expected.at(-1)},acc)}
+}`;
+            return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
+`}if((bits&${1 << i})!==0${condition}){
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-if(best===pos)acc=${catchName}(${i},prev,acc)
-prev=${i + 1}
+${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${i},prev,acc)
+prev=${i + 1}`}
 {const at=ctx._fe??pos
 if(at>best){best=at;acc=undefined}
-if(at===best)acc=_accSet(ctx._fx,acc)}
-if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
-${emitRollback(p, L.buf, sinks)}
-}`;
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(ctx._fx,acc)}
+if(ctx._fc===true){${startFailureExact ? `if(best===pos){acc=${catchName}(${i},0,undefined);acc=_accSet(ctx._fx,acc)}` : ""}if(acc!==undefined)ctx._fx=acc;return FAIL}
+${rollbackFor(i)}
+}${routeMiss}${sequenceMiss}`;
           }).join("\n") : "";
-          const generalArms = arms.map((arm, i) => `if(${gateRefs[i]}===null||classHas(${gateRefs[i]},c)){
+          const generalArms = arms.map((arm, i) => {
+            const pretest = pretests[i];
+            const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
+            const scalarCondition = pretest?.scalar === void 0 ? "" : pretest.scalar.length === 1 ? `&&${pretest.scalar[0]}(input,pos)>=0` : `&&(${pretest.scalar.map((recognize) => `${recognize}(input,pos)>=0`).join("||")})`;
+            const sequenceCondition = pretest?.sequence === void 0 ? "" : `&&(${decision}=${pretest.sequence.name}(input,pos))>=0`;
+            const condition = pretest?.token !== void 0 ? `&&(${decision}=${pretest.token.name}(input,pos))>0` : scalarCondition || sequenceCondition;
+            const miss = pretest?.sequence !== void 0 ? `else if(${decision}<0){
+ctx._fc=false
+const at=_pfSeqEnd
+if(at>best){best=at;acc=undefined}
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("")}${pretest.sequence.expected.at(-1)},acc)
+}${startFailureExact ? "" : `else if(best===pos)acc=_accSet(${expected[i]},acc)`}` : pretest?.token === void 0 ? startFailureExact ? "" : `else if(best===pos)acc=_accSet(${expected[i]},acc)` : `else if(${decision}===0){
+ctx._fc=false
+const at=_pfTokEnd
+if(at>best){best=at;acc=undefined}
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(${pretest.token.expected},acc)
+}${startFailureExact ? "" : `else if(best===pos)acc=_accSet(${expected[i]},acc)`}`;
+            return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
+`}if((${gateRefs[i]}===null||classHas(${gateRefs[i]},c))${condition}){
 ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
 if(at>best){best=at;acc=undefined}
-if(at===best)acc=_accSet(ctx._fx,acc)}
-if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
-${emitRollback(p, L.buf, sinks)}
-}else if(best===pos)acc=_accSet(${expected[i]},acc)`).join("\n");
+if(at===best${startFailureExact ? "&&at>pos" : ""})acc=_accSet(ctx._fx,acc)}
+if(ctx._fc===true){${startFailureExact ? `if(best===pos){acc=${catchName}(${i},0,undefined);acc=_accSet(ctx._fx,acc)}` : ""}if(acc!==undefined)ctx._fx=acc;return FAIL}
+${rollbackFor(i)}
+}${miss}`;
+          }).join("\n");
           return `${head}
 const c=lead(input,pos)
-${emitMark(p, L.buf, sinks)}
+${hasRollback ? emitMark(p, L.buf, L.raw, sinks) : ""}
 let acc
 let best=pos
 ${maskable ? `if(c<128){
 const bits=${maskName}[c<0?128:c]
-let prev=0
+if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
+${startFailureExact ? "" : "let prev=0"}
 ${maskArms}
-if(best===pos)acc=${catchName}(${n},prev,acc)
-ctx._fe=pos;ctx._fx=acc??${choiceFx}
+${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${n},prev,acc)`}
+ctx._fe=pos;ctx._fx=${startFailureExact ? `best===pos?${choiceFx}:acc??${choiceFx}` : `acc??${choiceFx}`}
 return FAIL
 }
 ` : ""}
 ${generalArms}
-ctx._fe=pos;ctx._fx=acc??${choiceFx}
+ctx._fe=pos;ctx._fx=${startFailureExact ? `best===pos?${choiceFx}:acc??${choiceFx}` : `acc??${choiceFx}`}
 return FAIL
 }`;
         }
@@ -9370,30 +10496,8 @@ return FAIL
         for (let i = 0; i < n; i++) arms.push(link(code[armBase + i]));
         const bk = hoist("bk", `DSP[${di}].byKey`);
         const dx = hoist("dx", `DSP[${di}].expected`);
-        const claims = (m) => {
-          switch (m[0]) {
-            case 0:
-              return `key.startsWith(${q(m[1])})`;
-            case 1:
-              return `key.endsWith(${q(m[1])})`;
-            case 3:
-              return `asciiFoldKey(key).startsWith(${q(m[1])})`;
-            case 4:
-              return `asciiFoldKey(key).endsWith(${q(m[1])})`;
-            default: {
-              if (!m[2].includes("g") && !m[2].includes("y")) {
-                try {
-                  new RegExp(m[1], m[2]);
-                  return `${hoist("dm", `new RegExp(${q(m[1])},${q(m[2])})`)}.test(key)`;
-                } catch {
-                }
-              }
-              return `new RegExp(${q(m[1])},${q(m[2])}).test(key)`;
-            }
-          }
-        };
         const chain = spec.match.length === 0 ? "" : `if(arm===undefined){
-${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${claims(m)})arm=${m[3]}`).join("\n")}
+${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${dispatchClaim(m)})arm=${m[3]}`).join("\n")}
 }
 `;
         const fold = spec.byFold.size > 0 ? `if(arm===undefined)arm=${hoist("bf", `DSP[${di}].byFold`)}.get(asciiFoldKey(key))
@@ -9401,33 +10505,43 @@ ${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${claims(m)})arm=${m[3]}
         const m1 = tmp();
         const m2 = tmp();
         const routedCall = (target) => `{const savedRouted=ctx._routed
-${emitRollback(m1, L.buf, sinks)}
-${emitMark(m2, L.buf, sinks, false)}
+${emitRollback(m1, L.buf, L.raw, sinks)}
+${emitMark(m2, L.buf, L.raw, sinks, false)}
 ctx._routed={value:key,span:{start:pos,end:selEnd}}
 try{v=${target}(input,pos,ctx)}finally{ctx._routed=savedRouted}
 break}`;
         const plainCall = (target) => `v=${target}(input,selEnd,ctx);break`;
         const armCases = arms.map((target, i) => `case ${i}:${spec.routed[i] === 1 ? routedCall(target) : plainCall(target)}`).join("\n");
         const fallbackCase = other === void 0 ? "" : `default:${otherRouted ? routedCall(other) : plainCall(other)}`;
+        const armSelection = tokenChoiceDispatches.has(ip) ? `const tp=_pfTokDispatch===${ip}&&_pfTokInput===input&&_pfTokPos===pos
+let arm
+if(tp){
+arm=_pfTokArm
+_pfTokDispatch=-1
+_pfTokInput=undefined
+if(arm===${n})arm=undefined
+}else{
+arm=${bk}.get(key)
+${fold}${chain}}` : `let arm=${bk}.get(key)
+${fold}${chain}`;
         return `${head}
-${emitMark(m1, L.buf, sinks)}
+${emitMark(m1, L.buf, L.raw, sinks)}
 const sv=${selector}(input,pos,ctx)
 if(sv===FAIL)return FAIL
 const selEnd=EC.e
 const key=sv
-let arm=${bk}.get(key)
-${fold}${chain}
+${armSelection}
 if(arm===undefined){
 ${other === void 0 ? `ctx._fe=selEnd;ctx._fx=${dx};return FAIL` : ""}
 }
-${emitMark(m2, L.buf, sinks)}
+${emitMark(m2, L.buf, L.raw, sinks)}
 let v
 switch(arm){
 ${armCases}
 ${fallbackCase}
 }
 if(v===FAIL){
-${emitRollback(m2, L.buf, sinks)}
+${emitRollback(m2, L.buf, L.raw, sinks)}
 ctx._fc=true
 return FAIL
 }
@@ -9463,23 +10577,25 @@ return [key,v]
         const skip = skipFor(L);
         const knownTrivia = L.tri === TRI_NONE ? false : L.tri !== TRI_UNKNOWN ? true : void 0;
         const hasTrivia = knownTrivia === void 0 ? "hasTrivia" : String(knownTrivia);
-        const pfd = sinks.fd ? `${p}fd` : "0";
+        const pfd = sinks.fd ? `${p}fd` : "undefined";
         const per = sinks.er ? `${p}er` : "undefined";
-        const rb = L.buf ? `_rbBuf(ctx,${p}raw,${p}tl,${p}lv,${p}lg,${p}rt)${sinks.fd ? `
+        const rbHelper = L.raw === RAW_OMIT ? "_rbNoRawBuf" : "_rbBuf";
+        const rb = L.buf && L.raw !== 0 ? `${rbHelper}(ctx,${p}raw,${p}tl,${p}lv,${p}lg,${p}rt)${sinks.fd ? `
 if(ctx._fields!==undefined&&ctx._fields.length!==${p}fd)ctx._fields.length=${p}fd` : ""}${sinks.er ? `
-if(ctx._errors!==undefined&&ctx._errors.length!==${p}er)ctx._errors.length=${p}er` : ""}` : `if(needMark)rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)`;
+if(ctx._errors!==undefined&&ctx._errors.length!==${p}er)ctx._errors.length=${p}er` : ""}` : L.buf ? `rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)` : `if(needMark)rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)`;
         const markSinks = `${sinks.fd ? `
 ${p}fd=ctx._fields!==undefined?ctx._fields.length:0` : ""}${sinks.er ? `
 ${p}er=ctx._errors!==undefined?ctx._errors.length:0` : ""}`;
+        const markRaw = L.raw === RAW_OMIT ? `${p}raw=b.rawLen` : L.raw === RAW_CAPTURE ? `const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0` : `const r=b.raw;${p}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)`;
         const markBody = L.buf ? `const b=ctx._cstBuf
-const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+${markRaw}
 const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${p}tl=l!==undefined?l.length:0
 ${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}` : `if(needMark){
 const b=ctx._cstBuf
 if(b!==undefined){
-const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const r=b.raw;${p}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)
 const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${p}tl=l!==undefined?l.length:0
 }else{
@@ -9586,7 +10702,7 @@ const leaf={_tag:'leaf',value,span:{start:pos,end}}
 const kids=[leaf],rawKids=[leaf],span={start:pos,end}
 EC.e=end
 const nd=${build2}(kids,undefined,span,rawKids,EMPTY_TL,undefined)
-${L.buf ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : "if(ctx._cstBuf!==undefined||ctx._cstChildren!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
+${L.buf && L.raw === RAW_OMIT ? "_pushNodeNoRawBuf(ctx,nd)" : L.buf && L.raw === RAW_CAPTURE ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : staticBuild ? "if(ctx._cstBuf!==undefined||ctx._cstChildren!==undefined)pushCstChild(ctx,nd,ctx._cstBuf!==undefined&&ctx._cstBuf.noRaw===true?undefined:ctx._cstBuf!==undefined||ctx._cstRawChildren!==undefined?rawEntry(nd,input,pos,end):undefined)" : "if(ctx._cstBuf!==undefined||ctx._cstChildren!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
 EC.e=end
 return nd
 }`;
@@ -9608,7 +10724,22 @@ return nd
         if (!hostCst && !tracked && build !== void 0 && proj < 0 && (flags === 2 || flags === 18 || flags === 34)) {
           const fields = flags === 18;
           const collapseChildren = flags === 34;
-          const publish = `if(sBuf!==undefined){
+          const publish = L.buf && L.raw === RAW_OMIT ? "_pushNodeNoRawBuf(ctx,nd)" : L.buf && L.raw === RAW_CAPTURE ? `if(sBuf!==undefined){
+if(sBuf.rawOnly!==true){
+if(sBuf.ch!==undefined)sBuf.ch.push(nd)
+else if(sBuf.single!==undefined){sBuf.ch=[sBuf.single,nd];sBuf.single=undefined}
+else sBuf.single=nd
+}
+const rawNd=rawEntry(nd,input,pos,end)
+if(sBuf.raw!==undefined)sBuf.raw.push(rawNd)
+else if(sBuf.rawSingle!==undefined){sBuf.raw=[sBuf.rawSingle,rawNd];sBuf.rawSingle=undefined}
+else sBuf.rawSingle=rawNd
+}else if(sCh!==undefined){
+sCh.push(nd)
+if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
+}` : `if(sBuf!==undefined){
+if(sBuf.noRaw===true)_pushNodeNoRawBuf(ctx,nd)
+else{
 if(sBuf.rawOnly!==true){
 if(sBuf.ch!==undefined)sBuf.ch.push(nd)
 else if(sBuf.single!==undefined){sBuf.ch=[sBuf.single,nd];sBuf.single=undefined}
@@ -9618,6 +10749,7 @@ const rawNd=rawEntry(nd,input,pos,end)
 if(sBuf.raw!==undefined)sBuf.raw.push(rawNd)
 else if(sBuf.rawSingle!==undefined){sBuf.raw=[sBuf.rawSingle,rawNd];sBuf.rawSingle=undefined}
 else sBuf.rawSingle=rawNd
+}
 }else if(sCh!==undefined){
 sCh.push(nd)
 if(sRaw!==undefined)sRaw.push(rawEntry(nd,input,pos,end))
@@ -9656,6 +10788,7 @@ return nd
         const wantFields = hasFields || hostCst;
         const captureWide = readsTrivia || hostCst ? !structural || grammarCapture || hostCapturesThisType !== false : hostCapturesThisType === true;
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
+        const omitsRaw = !hostCst && build !== void 0 && proj < 0 && (flags & 2) !== 0;
         const ty = q(type);
         const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
         const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
@@ -9669,7 +10802,12 @@ return nd
           value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):{_tag:'node',type:${ty},span,state:st??null,children:kids}`;
         }
         const collapsible = keepChildren && (hostCst || build === void 0 && proj < 0);
-        const openCapture = keepChildren ? `const buf={}
+        const openCapture = omitsRaw ? `const buf={noRaw:true,rawLen:0}
+ctx._cstBuf=buf
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined` : keepChildren ? `const buf={}
 ctx._cstBuf=buf
 ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
@@ -9680,7 +10818,10 @@ ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
 ctx._cstRawChildren=undefined
 ctx._cstTriviaLog=undefined`;
-        const finishCapture = keepChildren ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
+        const finishCapture = omitsRaw ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
+const hostKids=kids
+const rawKids=EMPTY_CH
+const tlog=buf.tl??EMPTY_TLOG` : keepChildren ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
 const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG` : `const kids=EMPTY_CH
@@ -9714,7 +10855,7 @@ const st=${readsState ? "(ctx.state!==undefined?Object.assign({},ctx.state):unde
 let nd
 ${unwrap ? "if(kids.length===1)nd=unwrapChild(kids[0])\nelse " : ""}${collapse ? "if(kids.length===1)nd=kids[0]\nelse " : ""}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
 else ` : ""}{${value}}
-${L.buf ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : "if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
+${L.buf && L.raw === RAW_OMIT ? "_pushNodeNoRawBuf(ctx,nd)" : L.buf && L.raw === RAW_CAPTURE ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : staticBuild ? "if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,sBuf!==undefined?(sBuf.noRaw===true?undefined:rawEntry(nd,input,pos,end)):sRaw!==undefined?rawEntry(nd,input,pos,end):undefined)" : "if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
 EC.e=end
 return nd
 }`;
@@ -9732,7 +10873,7 @@ return nd
   }
   const extra = [];
   for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`);
-  const source = `${RUNTIME_PRELUDE}
+  const source = `${RUNTIME_PRELUDE}${needsNoRawPrelude ? NO_RAW_RUNTIME_PRELUDE : ""}
 ${prelude.join("\n")}
 ${skipDefs.join("\n")}
 ${choiceDefs.join("\n")}
@@ -9747,7 +10888,13 @@ _pfHost=host
 function _finish(){
 if(_pfDepth<=0)throw new Error('parseman emitted table assembly frame underflow')
 _pfDepth--
-if(_pfDepth===0)return
+if(_pfDepth===0){
+_pfTokInput=undefined
+_pfTokBody=-1
+_pfTokValue=undefined
+_pfTokDispatch=-1
+return
+}
 const prior=_pfFrames.pop()
 _pfScan=prior[0]
 _pfHost=prior[1]
@@ -10109,6 +11256,17 @@ function assemble(t, prog, cfg) {
     }
     return recognize;
   }
+  const labelExtraIps = [];
+  for (const s of prog.scans ?? []) {
+    for (const r of s.skip) labelExtraIps.push(r[0]);
+    if (s.sentinel !== void 0) labelExtraIps.push(s.sentinel[0]);
+  }
+  for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
+  const closureLabels = computeSiteLabels(
+    code,
+    [...Object.values(prog.rules), ...labelExtraIps],
+    hostCst
+  );
   let SCAN = null;
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
@@ -10154,12 +11312,12 @@ function assemble(t, prog, cfg) {
       return node2;
     };
   }
-  function capturedFlatChildren(children2) {
-    if (children2.length === 0) return EMPTY_CH;
-    if (children2[0] !== void 0) return children2;
+  function capturedFlatChildren(children3) {
+    if (children3.length === 0) return EMPTY_CH;
+    if (children3[0] !== void 0) return children3;
     let first = 1;
-    while (first < children2.length && children2[first] === void 0) first++;
-    return first === children2.length ? EMPTY_CH : children2.slice(first);
+    while (first < children3.length && children3[first] === void 0) first++;
+    return first === children3.length ? EMPTY_CH : children3.slice(first);
   }
   function childrenOnlyBuildNode(child, build) {
     return (input, pos, ctx) => {
@@ -10354,7 +11512,7 @@ function assemble(t, prog, cfg) {
     const b = ctx._cstBuf;
     if (b !== void 0) {
       const raw = b.raw;
-      MRAW = raw !== void 0 ? raw.length : b.rawSingle !== void 0 ? 1 : 0;
+      MRAW = b.noRaw === true ? b.rawLen ?? 0 : raw !== void 0 ? raw.length : b.rawSingle !== void 0 ? 1 : 0;
       const ch2 = b.ch;
       MLV = ch2 !== void 0 ? ch2.length : b.single !== void 0 ? 1 : 0;
       const tl = b.tl;
@@ -10438,6 +11596,31 @@ function assemble(t, prog, cfg) {
     if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
+  function nextTermBuffered(child, input, cur, ctx) {
+    if (ctx.trivia === void 0) {
+      const v2 = child(input, cur, ctx);
+      if (v2 === FAIL) return -1;
+      TERMV = v2;
+      return EC.e;
+    }
+    const before = ctx._cstBuf;
+    const beforeTl = before.tl;
+    const mTl = beforeTl === void 0 ? 0 : beforeTl.length;
+    const mLog = ctx._triviaLog?.length ?? 0;
+    const mRoot = ctx._rootTriviaLog?.length ?? 0;
+    const scanEnd = skipTrivia(input, cur, ctx);
+    const scanned = ctx._cstBuf;
+    const scannedTl = scanned.tl;
+    const scanTl = scannedTl === void 0 ? 0 : scannedTl.length;
+    const scanLog = ctx._triviaLog?.length ?? 0;
+    const scanRoot = ctx._rootTriviaLog?.length ?? 0;
+    const v = child(input, scanEnd, ctx);
+    if (v === FAIL) return -1;
+    TERMV = v;
+    if (EC.e > scanEnd) return EC.e;
+    rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
+    return cur;
+  }
   function committed3(c) {
     return c._fc === true;
   }
@@ -10708,7 +11891,8 @@ function assemble(t, prog, cfg) {
       target = p;
     } };
     inFlight.set(ip, holder);
-    const piece = lower(ip);
+    const op = code[ip];
+    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : lower(ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
@@ -11160,11 +12344,11 @@ function assemble(t, prog, cfg) {
       }
       case OP_ROUTED: {
         const fb = code[ip + 1];
-        const fallback = fb >= 0 ? link(fb) : void 0;
+        const fallback2 = fb >= 0 ? link(fb) : void 0;
         return (input, pos, ctx) => {
           const item = ctx._routed;
           if (item === void 0 || pos !== item.span.start) {
-            if (fallback !== void 0) return fallback(input, pos, ctx);
+            if (fallback2 !== void 0) return fallback2(input, pos, ctx);
             ctx._fe = pos;
             ctx._fx = ROUTED_FX;
             return FAIL;
@@ -11451,6 +12635,7 @@ function assemble(t, prog, cfg) {
         const reducer = fused ? code[ip + 1] : -1;
         const projection = reducer < 0 ? ~reducer : -1;
         const fn = fused && projection < 0 ? fns[reducer] : void 0;
+        const step = closureLabels.at(ip).buf ? nextTermBuffered : nextTerm;
         const runnerBlock = (count, r0, r1, r2, r3, next) => {
           if (count === 1) return (input, cur, ctx, values, inherited) => {
             cur = r0(input, cur, ctx, inherited);
@@ -11505,7 +12690,7 @@ function assemble(t, prog, cfg) {
               const kid = link(kidIp);
               return (input, cur, ctx, inherited) => {
                 ctx._sync = sync ?? inherited;
-                return nextTerm(kid, input, cur, ctx);
+                return step(kid, input, cur, ctx);
               };
             }
             const negated = code[kidIp + 1] === 1;
@@ -11590,7 +12775,7 @@ function assemble(t, prog, cfg) {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
-              return (input, cur, ctx) => nextTerm(kid, input, cur, ctx);
+              return (input, cur, ctx) => step(kid, input, cur, ctx);
             }
             const negated = code[kidIp + 1] === 1;
             const ki = code[kidIp + 2];
@@ -11679,7 +12864,7 @@ function assemble(t, prog, cfg) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
               if (v0 === FAIL) return FAIL;
-              const cur = nextTerm(k1, input, EC.e, ctx);
+              const cur = step(k1, input, EC.e, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
               return projection === 0 ? v0 : projection === 1 ? TERMV : fn([v0, TERMV], { start: pos, end: cur });
@@ -11689,7 +12874,7 @@ function assemble(t, prog, cfg) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
               if (v0 === FAIL) return FAIL;
-              const cur = nextTerm(k1, input, EC.e, ctx);
+              const cur = step(k1, input, EC.e, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
               return [v0, TERMV];
@@ -11698,7 +12883,7 @@ function assemble(t, prog, cfg) {
           return (input, pos, ctx) => {
             const v0 = k0(input, pos, ctx);
             if (v0 === FAIL) return FAIL;
-            const cur = nextTerm(k1, input, EC.e, ctx);
+            const cur = step(k1, input, EC.e, ctx);
             if (cur < 0) return FAIL;
             EC.e = cur;
             return void 0;
@@ -11710,10 +12895,10 @@ function assemble(t, prog, cfg) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
               if (v0 === FAIL) return FAIL;
-              let cur = nextTerm(k1, input, EC.e, ctx);
+              let cur = step(k1, input, EC.e, ctx);
               if (cur < 0) return FAIL;
               const v1 = TERMV;
-              cur = nextTerm(k2, input, cur, ctx);
+              cur = step(k2, input, cur, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
               return projection === 0 ? v0 : projection === 1 ? v1 : projection === 2 ? TERMV : fn([v0, v1, TERMV], { start: pos, end: cur });
@@ -11723,10 +12908,10 @@ function assemble(t, prog, cfg) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
               if (v0 === FAIL) return FAIL;
-              let cur = nextTerm(k1, input, EC.e, ctx);
+              let cur = step(k1, input, EC.e, ctx);
               if (cur < 0) return FAIL;
               const v1 = TERMV;
-              cur = nextTerm(k2, input, cur, ctx);
+              cur = step(k2, input, cur, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
               return [v0, v1, TERMV];
@@ -11735,9 +12920,9 @@ function assemble(t, prog, cfg) {
           return (input, pos, ctx) => {
             const v0 = k0(input, pos, ctx);
             if (v0 === FAIL) return FAIL;
-            let cur = nextTerm(k1, input, EC.e, ctx);
+            let cur = step(k1, input, EC.e, ctx);
             if (cur < 0) return FAIL;
-            cur = nextTerm(k2, input, cur, ctx);
+            cur = step(k2, input, cur, ctx);
             if (cur < 0) return FAIL;
             EC.e = cur;
             return void 0;
@@ -11745,43 +12930,43 @@ function assemble(t, prog, cfg) {
         }
         const block = (count, k0, k1, k2, k3, next) => {
           if (count === 1) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx);
+            cur = step(k0, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
             return next === void 0 ? cur : next(input, cur, ctx, values);
           };
           if (count === 2) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx);
+            cur = step(k0, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k1, input, cur, ctx);
+            cur = step(k1, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
             return next === void 0 ? cur : next(input, cur, ctx, values);
           };
           if (count === 3) return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx);
+            cur = step(k0, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k1, input, cur, ctx);
+            cur = step(k1, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k2, input, cur, ctx);
+            cur = step(k2, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
             return next === void 0 ? cur : next(input, cur, ctx, values);
           };
           return (input, cur, ctx, values) => {
-            cur = nextTerm(k0, input, cur, ctx);
+            cur = step(k0, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k1, input, cur, ctx);
+            cur = step(k1, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k2, input, cur, ctx);
+            cur = step(k2, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-            cur = nextTerm(k3, input, cur, ctx);
+            cur = step(k3, input, cur, ctx);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
             return next === void 0 ? cur : next(input, cur, ctx, values);
@@ -11952,6 +13137,13 @@ function assemble(t, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
+          const predecide = !hostCst && !REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
+          const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
+          const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
+          const p0 = p0ip < 0 ? void 0 : scalarFor(p0ip);
+          const p1 = p1ip < 0 ? void 0 : scalarFor(p1ip);
+          const p2 = p2ip < 0 ? void 0 : scalarFor(p2ip);
           const e0 = fx[code[base + n]];
           const e1 = fx[code[base + n + 1]];
           const e2 = n === 3 ? fx[code[base + n + 2]] : void 0;
@@ -11981,7 +13173,10 @@ function assemble(t, prog, cfg) {
             let acc;
             let best = pos;
             if (c < 128) {
-              const bits = mask[c < 0 ? 128 : c];
+              let bits = mask[c < 0 ? 128 : c];
+              if ((bits & 1) !== 0 && p0 !== void 0 && p0(input, pos) < 0) bits &= ~1;
+              if ((bits & 2) !== 0 && p1 !== void 0 && p1(input, pos) < 0) bits &= ~2;
+              if ((bits & 4) !== 0 && p2 !== void 0 && p2(input, pos) < 0) bits &= ~4;
               let prev = 0;
               if ((bits & 1) !== 0) {
                 ctx._fc = false;
@@ -12044,7 +13239,7 @@ function assemble(t, prog, cfg) {
               ctx._fx = acc ?? choiceFx;
               return FAIL;
             }
-            if (g0 === null || classHas2(g0, c)) {
+            if ((g0 === null || classHas2(g0, c)) && (p0 === void 0 || p0(input, pos) >= 0)) {
               ctx._fc = false;
               const v = a0(input, pos, ctx);
               if (v !== FAIL) return v;
@@ -12060,7 +13255,7 @@ function assemble(t, prog, cfg) {
               }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
             } else if (best === pos) acc = accSet(e0, acc);
-            if (g1 === null || classHas2(g1, c)) {
+            if ((g1 === null || classHas2(g1, c)) && (p1 === void 0 || p1(input, pos) >= 0)) {
               ctx._fc = false;
               const v = a1(input, pos, ctx);
               if (v !== FAIL) return v;
@@ -12077,7 +13272,7 @@ function assemble(t, prog, cfg) {
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
             } else if (best === pos) acc = accSet(e1, acc);
             if (n === 3) {
-              if (g2 === null || classHas2(g2, c)) {
+              if ((g2 === null || classHas2(g2, c)) && (p2 === void 0 || p2(input, pos) >= 0)) {
                 ctx._fc = false;
                 const v = a2(input, pos, ctx);
                 if (v !== FAIL) return v;
@@ -12650,20 +13845,14 @@ function assemble(t, prog, cfg) {
         const captureWide = readsTrivia || hostCst ? !structural || grammarCapture || hostCapturesThisType !== false : hostCapturesThisType === true;
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
         const rawOnly = !keepChildren;
+        const omitsRaw = !hostCst && build !== void 0 && proj < 0 && (flags & 2) !== 0;
         return (input, pos, ctx) => {
           const host = HOST;
           const sCh = ctx._cstChildren;
-          const sLv = ctx._cstLeaves;
-          const sRaw = ctx._cstRawChildren;
-          const sTl = ctx._cstTriviaLog;
           const sCap = ctx.captureTrivia;
           const sBuf = ctx._cstBuf;
-          const buf = rawOnly ? { rawOnly: true } : {};
+          const buf = rawOnly ? { rawOnly: true } : omitsRaw ? { noRaw: true, rawLen: 0 } : {};
           ctx._cstBuf = buf;
-          ctx._cstChildren = void 0;
-          ctx._cstLeaves = void 0;
-          ctx._cstRawChildren = void 0;
-          ctx._cstTriviaLog = void 0;
           ctx.captureTrivia = captureWide;
           const savedFields = ctx._fields;
           ctx._fields = wantFields ? [] : void 0;
@@ -12678,13 +13867,9 @@ function assemble(t, prog, cfg) {
           if (structural) ctx._triviaCaptureMask = savedMask;
           const kids = rawOnly ? EMPTY_CH : buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY_CH);
           const hostKids = kids;
-          const rawKids = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY_CH);
+          const rawKids = omitsRaw ? EMPTY_CH : buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY_CH);
           const tlog = buf.tl ?? EMPTY_TLOG;
           ctx._cstBuf = sBuf;
-          ctx._cstChildren = sCh;
-          ctx._cstLeaves = sLv;
-          ctx._cstRawChildren = sRaw;
-          ctx._cstTriviaLog = sTl;
           ctx.captureTrivia = sCap;
           if (v === FAIL) return FAIL;
           const end = EC.e;
@@ -12775,6 +13960,34 @@ function assemble(t, prog, cfg) {
             rawScalarSpecs.add(code[child + 1]);
             scalarFor(child);
           }
+        } else if (code[ip] === OP_CHOICE && !disp[code[ip + 1]].exclusive) {
+          const n = code[ip + 2];
+          for (let i = 0; i < n; i++) {
+            const armIp = code[ip + 4 + i];
+            const child = leadingScalarTerminal(code, armIp, 2, true, true);
+            if (n === 2 || n === 3) {
+              if (child >= 0) scalarFor(child);
+              continue;
+            }
+            if (child >= 0) {
+              const spec = k[code[child + 1]];
+              if (code[child] === OP_LIT && typeof spec === "string" && spec.length >= 2) {
+                scalarFor(child);
+                continue;
+              }
+            }
+            const family = leadingLiteralFamily(code, k, armIp);
+            if (family !== void 0 && family.length >= 2 && family.every((terminal) => {
+              const value = k[code[terminal + 1]];
+              return typeof value === "string" && value.length >= 2;
+            })) {
+              for (const terminal of family) scalarFor(terminal);
+            }
+            const sequence6 = leadingScalarSequence(code, armIp);
+            if (sequence6 !== void 0 && (sequence6.trivia < 0 || triviaScan[sequence6.trivia] != null)) {
+              for (const terminal of sequence6.terminals) scalarFor(terminal);
+            }
+          }
         }
       }
       const notChild = scalarTerminalNotChild(code, ip);
@@ -13196,7 +14409,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t, prog, cfg, extraIps);
+      em = emitAssemblySource(t, prog, cfg, extraIps, true);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -13655,10 +14868,10 @@ function boundaryMatches(boundary, ch2) {
       if (/\s/.test(ch2)) return true;
       continue;
     }
-    const range = /^(.|\\u[0-9a-f]{4})-(.|\\u[0-9a-f]{4})$/.exec(m);
-    if (range !== null) {
+    const range2 = /^(.|\\u[0-9a-f]{4})-(.|\\u[0-9a-f]{4})$/.exec(m);
+    if (range2 !== null) {
       const dec = (t) => t.startsWith("\\u") ? parseInt(t.slice(2), 16) : t.codePointAt(0);
-      if (cp >= dec(range[1]) && cp <= dec(range[2])) return true;
+      if (cp >= dec(range2[1]) && cp <= dec(range2[2])) return true;
       continue;
     }
     if (m === ch2) return true;
@@ -14732,7 +15945,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   };
   const { prog, fnSrcs } = encodeTableProgram({ [ENTRY]: combinator }, settings);
   const artifact = closureArtifact(prog);
-  const entry = tableRules(artifact)[ENTRY];
+  const entry = tableRules(prog)[ENTRY];
   const offered = opts.fnSources ?? mapFnSources;
   const supplied = offered !== void 0 && offered.length === fnSrcs.length ? offered : void 0;
   const sources = fnSrcs.map((s, i) => s ?? supplied?.[i] ?? ownSource(prog.fns[i]));
@@ -14781,106 +15994,6 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   };
 }
 
-// src/analysis/commitment.ts
-function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "node":
-      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
-    case "lazy": {
-      try {
-        return hasDirectBuildDef(d.thunk(), seen);
-      } catch {
-        return false;
-      }
-    }
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "attempt":
-    case "not":
-    case "peek":
-    case "withCtx":
-    case "expect":
-    case "transform":
-      return hasDirectBuildDef(d.parser, seen);
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
-    case "dispatch":
-      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
-    case "sepBy":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
-    case "scanTo":
-      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen));
-    case "recover":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
-    case "routed":
-      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
-    default:
-      return false;
-  }
-}
-function hasSemanticReduction(roots, externalRefs) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (parser2) => {
-    if (seen.has(parser2)) return false;
-    seen.add(parser2);
-    const def = parser2._def;
-    if (def.tag === "transform" && !def.recognitionOnly) return true;
-    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
-    if (def.tag === "guard" || def.tag === "withCtx") return true;
-    if (def.tag === "node" && def.build !== void 0) return true;
-    if (def.tag === "lazy") {
-      if (externalRefs?.has(parser2)) return false;
-      try {
-        return visit(def.thunk());
-      } catch {
-        return true;
-      }
-    }
-    return childrenOf2(def).some(visit);
-  };
-  return roots.some(visit);
-}
-function classifyRuleMap(ruleMap) {
-  const externalRefs = /* @__PURE__ */ new Set();
-  const scanned = /* @__PURE__ */ new Set();
-  const scanExternal = (p) => {
-    if (scanned.has(p)) return;
-    scanned.add(p);
-    const def = p._def;
-    if (def.tag === "lazy") {
-      let resolved;
-      try {
-        resolved = def.thunk();
-      } catch {
-        resolved = void 0;
-      }
-      if (resolved === void 0) {
-        if (p._ruleName) externalRefs.add(p);
-        return;
-      }
-      scanExternal(resolved);
-      return;
-    }
-    for (const child of childrenOf2(def)) scanExternal(child);
-  };
-  for (const [, rule] of ruleMap) scanExternal(rule);
-  return {
-    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
-  };
-}
-
 // src/combinators/withCtx.ts
 function withCtx(extra, combinator) {
   const meta = {
@@ -15023,7 +16136,7 @@ function evalRuleMapIR(ir) {
     l._def.fnSrc = src;
     return l;
   };
-  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports) => {
+  const _nd = (type, child, src, opts, staticError, sigSrc, buildImports, rawUnused) => {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
     }
@@ -15033,6 +16146,7 @@ function evalRuleMapIR(ir) {
     n._def.buildSrc = src;
     if (staticError !== void 0) n._def.buildStaticError = staticError;
     if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
+    if (rawUnused === true) n._def.buildRawUnused = true;
     if (buildImports !== void 0) n._def.buildImports = buildImports;
     return n;
   };
@@ -15425,12 +16539,13 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         }
         if (def.buildSrc !== void 0) {
           const tail = [];
-          if (def.buildStaticError !== void 0 || def.buildSigSrc !== void 0 || def.buildImports !== void 0) {
+          if (def.buildStaticError !== void 0 || def.buildSigSrc !== void 0 || def.buildImports !== void 0 || def.buildRawUnused === true) {
             if (!opts) tail.push("undefined");
             tail.push(def.buildStaticError === void 0 ? "undefined" : JSON.stringify(def.buildStaticError));
           }
-          if (def.buildSigSrc !== void 0 || def.buildImports !== void 0) tail.push(def.buildSigSrc === void 0 ? "undefined" : JSON.stringify(def.buildSigSrc));
-          if (def.buildImports !== void 0) tail.push(JSON.stringify(def.buildImports));
+          if (def.buildSigSrc !== void 0 || def.buildImports !== void 0 || def.buildRawUnused === true) tail.push(def.buildSigSrc === void 0 ? "undefined" : JSON.stringify(def.buildSigSrc));
+          if (def.buildImports !== void 0 || def.buildRawUnused === true) tail.push(def.buildImports === void 0 ? "undefined" : JSON.stringify(def.buildImports));
+          if (def.buildRawUnused === true) tail.push("true");
           const trailing = tail.length > 0 ? `, ${tail.join(", ")}` : "";
           return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts}${trailing})`;
         }
@@ -15499,7 +16614,7 @@ function compileRuleMapRunnable(ruleMap, opts = {}) {
     hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(artifact),
+    rules: tableRules(prog),
     prog: artifact
   };
 }
@@ -15571,13 +16686,13 @@ function compileRuleMap(ruleMap, opts = {}) {
     hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     reflection: collectGrammarReflection(ruleMap),
     ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    rules: tableRules(artifact),
+    rules: tableRules(prog),
     prog: artifact
   };
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.49.0";
+var PARSEMAN_VERSION = "0.50.1";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -15653,16 +16768,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state, tags) {
-  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children2] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
+function buildCstNode(type, children3, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children3] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children3] };
 }
-function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state, _tags) {
+function cstBuildHost(typeOrOptions, children3, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
-    return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
+    return buildCstNode(typeOrOptions, children3 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
   const materializeTags = typeOrOptions?.tags === true;
-  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
+  const host = (type, children4, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children4 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -15818,39 +16933,39 @@ function directBuilderBindings(src) {
   if (selfName?.type === "Identifier" && typeof selfName.name === "string") allowed.add(selfName.name);
   const structural = /* @__PURE__ */ new Set();
   const free = /* @__PURE__ */ new Set();
-  const reportUnsupportedNode = (ast) => {
-    structural.add(`unsupported ${ast.type}`);
+  const reportUnsupportedNode = (ast2) => {
+    structural.add(`unsupported ${ast2.type}`);
   };
-  const read = (ast, allowedNames) => {
-    if (typeof ast.name === "string" && allowedNames.has(ast.name)) return;
-    if (ast.name === "arguments") {
+  const read = (ast2, allowedNames) => {
+    if (typeof ast2.name === "string" && allowedNames.has(ast2.name)) return;
+    if (ast2.name === "arguments") {
       structural.add("unsupported arguments");
       return;
     }
-    if (typeof ast.name === "string") free.add(ast.name);
+    if (typeof ast2.name === "string") free.add(ast2.name);
     else structural.add("unsupported identifier");
   };
   const expression = (node2, allowedNames) => {
-    const ast = astChild(node2);
-    if (!ast) return;
-    switch (ast.type) {
+    const ast2 = astChild(node2);
+    if (!ast2) return;
+    switch (ast2.type) {
       case "Literal":
         return;
       case "Identifier":
-        read(ast, allowedNames);
+        read(ast2, allowedNames);
         return;
       case "ParenthesizedExpression":
       case "ChainExpression":
       case "TSAsExpression":
       case "TSTypeAssertion":
       case "TSNonNullExpression":
-        expression(ast.expression, allowedNames);
+        expression(ast2.expression, allowedNames);
         return;
       case "ArrayExpression":
-        for (const element of astArray(ast.elements)) expression(element, allowedNames);
+        for (const element of astArray(ast2.elements)) expression(element, allowedNames);
         return;
       case "ObjectExpression":
-        for (const property of astArray(ast.properties)) {
+        for (const property of astArray(ast2.properties)) {
           if (property.type === "SpreadElement") {
             expression(property.argument, allowedNames);
             continue;
@@ -15864,109 +16979,109 @@ function directBuilderBindings(src) {
         }
         return;
       case "MemberExpression":
-        expression(ast.object, allowedNames);
-        if (ast.computed === true) expression(ast.property, allowedNames);
+        expression(ast2.object, allowedNames);
+        if (ast2.computed === true) expression(ast2.property, allowedNames);
         return;
       case "CallExpression":
       case "NewExpression":
-        expression(ast.callee, allowedNames);
-        for (const argument of astArray(ast.arguments)) expression(argument, allowedNames);
+        expression(ast2.callee, allowedNames);
+        for (const argument of astArray(ast2.arguments)) expression(argument, allowedNames);
         return;
       case "UnaryExpression":
       case "UpdateExpression":
-        expression(ast.argument, allowedNames);
+        expression(ast2.argument, allowedNames);
         return;
       case "BinaryExpression":
       case "LogicalExpression":
       case "AssignmentExpression":
-        expression(ast.left, allowedNames);
-        expression(ast.right, allowedNames);
+        expression(ast2.left, allowedNames);
+        expression(ast2.right, allowedNames);
         return;
       case "ConditionalExpression":
-        expression(ast.test, allowedNames);
-        expression(ast.consequent, allowedNames);
-        expression(ast.alternate, allowedNames);
+        expression(ast2.test, allowedNames);
+        expression(ast2.consequent, allowedNames);
+        expression(ast2.alternate, allowedNames);
         return;
       case "SequenceExpression":
-        for (const value of astArray(ast.expressions)) expression(value, allowedNames);
+        for (const value of astArray(ast2.expressions)) expression(value, allowedNames);
         return;
       case "TemplateLiteral":
-        for (const value of astArray(ast.expressions)) expression(value, allowedNames);
+        for (const value of astArray(ast2.expressions)) expression(value, allowedNames);
         return;
       case "SpreadElement":
-        expression(ast.argument, allowedNames);
+        expression(ast2.argument, allowedNames);
         return;
       case "ArrowFunctionExpression": {
         const nested = new Set(allowedNames);
-        for (const param of astArray(ast.params)) {
+        for (const param of astArray(ast2.params)) {
           if (param.type !== "Identifier" || typeof param.name !== "string") {
             reportUnsupportedNode(param);
             continue;
           }
           nested.add(param.name);
         }
-        const nestedBody = astChild(ast.body);
+        const nestedBody = astChild(ast2.body);
         if (nestedBody?.type === "BlockStatement") {
           statement(nestedBody, nested);
           return;
         }
-        expression(ast.body, nested);
+        expression(ast2.body, nested);
         return;
       }
       default:
-        reportUnsupportedNode(ast);
+        reportUnsupportedNode(ast2);
         return;
     }
   };
   const statement = (node2, names) => {
-    const ast = astChild(node2);
-    if (!ast) return;
-    switch (ast.type) {
+    const ast2 = astChild(node2);
+    if (!ast2) return;
+    switch (ast2.type) {
       case "VariableDeclaration":
-        for (const d of astArray(ast.declarations)) {
+        for (const d of astArray(ast2.declarations)) {
           expression(d.init, names);
           const idAst = astChild(d.id);
           if (idAst?.type === "Identifier" && typeof idAst.name === "string") names.add(idAst.name);
-          else reportUnsupportedNode(idAst ?? ast);
+          else reportUnsupportedNode(idAst ?? ast2);
         }
         return;
       case "ReturnStatement":
-        expression(ast.argument, names);
+        expression(ast2.argument, names);
         return;
       case "ExpressionStatement":
-        expression(ast.expression, names);
+        expression(ast2.expression, names);
         return;
       case "ThrowStatement":
-        expression(ast.argument, names);
+        expression(ast2.argument, names);
         return;
       case "IfStatement":
-        expression(ast.test, names);
-        statement(ast.consequent, new Set(names));
-        if (ast.alternate) statement(ast.alternate, new Set(names));
+        expression(ast2.test, names);
+        statement(ast2.consequent, new Set(names));
+        if (ast2.alternate) statement(ast2.alternate, new Set(names));
         return;
       case "ForStatement": {
         const inner = new Set(names);
-        if (ast.init) {
-          const initAst = astChild(ast.init);
+        if (ast2.init) {
+          const initAst = astChild(ast2.init);
           if (initAst?.type === "VariableDeclaration") statement(initAst, inner);
           else expression(initAst, inner);
         }
-        if (ast.test) expression(ast.test, inner);
-        if (ast.update) expression(ast.update, inner);
-        statement(ast.body, inner);
+        if (ast2.test) expression(ast2.test, inner);
+        if (ast2.update) expression(ast2.update, inner);
+        statement(ast2.body, inner);
         return;
       }
       case "ForOfStatement":
       case "ForInStatement": {
         const inner = new Set(names);
-        statement(ast.left, inner);
-        expression(ast.right, names);
-        statement(ast.body, inner);
+        statement(ast2.left, inner);
+        expression(ast2.right, names);
+        statement(ast2.body, inner);
         return;
       }
       case "BlockStatement": {
         const inner = new Set(names);
-        for (const s of astArray(ast.body)) statement(s, inner);
+        for (const s of astArray(ast2.body)) statement(s, inner);
         return;
       }
       case "BreakStatement":
@@ -15974,7 +17089,7 @@ function directBuilderBindings(src) {
       case "EmptyStatement":
         return;
       default:
-        reportUnsupportedNode(ast);
+        reportUnsupportedNode(ast2);
         return;
     }
   };
@@ -16413,6 +17528,7 @@ function exprToCombi(node2, scope, code, mfs) {
     try {
       const combi = explicitType !== void 0 ? node(explicitType, inner, hasBuild ? () => null : void 0, opts) : node(inner, hasBuild ? () => null : void 0, opts);
       if (combi._def.tag === "node" && buildSrc !== void 0) {
+        const authorDeclaredBuildArity = opts?.buildArity !== void 0;
         combi._def.buildSrc = buildSrc;
         if (explicitType !== void 0 && firstArg.type === "Identifier") {
           combi._def.typeSrc = firstArg.name;
@@ -16427,6 +17543,9 @@ function exprToCombi(node2, scope, code, mfs) {
           if (resolved.reason !== void 0) combi._def.buildArityUnresolved = resolved.reason;
         }
         const analysisSrc = combi._def.buildSigSrc ?? buildSrc;
+        if (!authorDeclaredBuildArity && confirmedBuildParamUnused(analysisSrc, 3)) {
+          combi._def.buildRawUnused = true;
+        }
         const report = directBuilderBindings(analysisSrc);
         const isInlineBuilder = combi._def.buildSigSrc === void 0;
         const carriedImports = [];
@@ -16980,8 +18099,8 @@ var SCOPE_TYPES = /* @__PURE__ */ new Set([
   "ClassExpression",
   "StaticBlock"
 ]);
-function newScope(start, end, parent, isFunction) {
-  const s = { start, end, bindings: /* @__PURE__ */ new Map(), children: [], parent, isFunction };
+function newScope(start, end, parent, isFunction2) {
+  const s = { start, end, bindings: /* @__PURE__ */ new Map(), children: [], parent, isFunction: isFunction2 };
   parent?.children.push(s);
   return s;
 }
@@ -17567,6 +18686,456 @@ function findFreeIdentifiers(code, filename) {
   }).map(({ name, line, column, enclosing }) => ({ name, line, column, enclosing }));
 }
 
+// src/plugin/entry-supercompiler.ts
+import { parseSync as parseSync4 } from "oxc-parser";
+var PIECE = /^_pf(\d+)$/;
+var WRAP = "function __parseman_supercompile__(){\n";
+var SUFFIX = "\n}";
+function ast(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function nodes(value) {
+  return Array.isArray(value) ? value.filter((v) => ast(v) !== void 0) : [];
+}
+function nameOf(node2) {
+  return node2?.type === "Identifier" && typeof node2.name === "string" ? node2.name : void 0;
+}
+function range(node2) {
+  if (typeof node2.start !== "number" || typeof node2.end !== "number") throw new Error("entry supercompiler: AST node without range");
+  return { start: node2.start - WRAP.length, end: node2.end - WRAP.length };
+}
+function children2(node2) {
+  const out = [];
+  for (const [key, value] of Object.entries(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        const c = ast(child);
+        if (c !== void 0) out.push(c);
+      }
+    } else {
+      const c = ast(value);
+      if (c !== void 0) out.push(c);
+    }
+  }
+  return out;
+}
+function isFunction(node2) {
+  return node2.type === "FunctionDeclaration" || node2.type === "FunctionExpression" || node2.type === "ArrowFunctionExpression";
+}
+function isDirectCallUse(call, parent, statement) {
+  if (parent === void 0) return false;
+  if (parent.type === "VariableDeclarator") {
+    const declarations = statement.type === "VariableDeclaration" ? nodes(statement.declarations) : [];
+    return declarations.length === 1 && declarations[0] === parent && parent.init === call;
+  }
+  if (parent.type === "AssignmentExpression") {
+    return statement.type === "ExpressionStatement" && statement.expression === parent && nameOf(ast(parent.left)) !== void 0 && parent.right === call && parent.operator === "=";
+  }
+  if (parent.type === "ReturnStatement") return statement === parent && parent.argument === call;
+  return false;
+}
+function isListStatement(statement, parent) {
+  if (parent?.type === "BlockStatement") return nodes(parent.body).includes(statement);
+  if (parent?.type === "SwitchCase") return nodes(parent.consequent).includes(statement);
+  return false;
+}
+function hasInlineScopeHazard(fn) {
+  if (fn.node.async === true || fn.node.generator === true) return true;
+  let hazard = false;
+  const walk = (node2) => {
+    if (hazard) return;
+    if (node2.type === "Identifier" && node2.name === "arguments") hazard = true;
+    else if (node2.type === "ThisExpression") hazard = true;
+    else if (node2.type === "VariableDeclaration" && node2.kind === "var") hazard = true;
+    else if (node2.type === "MetaProperty" && nameOf(ast(node2.meta)) === "new" && nameOf(ast(node2.property)) === "target") hazard = true;
+    else for (const child of children2(node2)) walk(child);
+  };
+  walk(fn.body);
+  return hazard;
+}
+function hasInlineSignature(fn) {
+  const params = nodes(fn.node.params);
+  return params.length === 3 && nameOf(params[0]) === "input" && nameOf(params[1]) === "pos" && nameOf(params[2]) === "ctx";
+}
+function render2(source, start, end, edits) {
+  const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+  let at = start;
+  let out = "";
+  for (const edit of ordered) {
+    if (edit.start < at || edit.end < edit.start || edit.start < start || edit.end > end) {
+      throw new Error("entry supercompiler: overlapping or out-of-range structured edit");
+    }
+    out += source.slice(at, edit.start) + edit.text;
+    at = edit.end;
+  }
+  return out + source.slice(at, end);
+}
+function recursiveMembers(fns) {
+  let next = 0;
+  const index = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
+  const stack = [];
+  const on = /* @__PURE__ */ new Set();
+  const recursive = /* @__PURE__ */ new Set();
+  const visit = (ip) => {
+    index.set(ip, next);
+    low.set(ip, next);
+    next++;
+    stack.push(ip);
+    on.add(ip);
+    for (const call of fns.get(ip)?.calls ?? []) {
+      if (!fns.has(call.callee)) continue;
+      if (!index.has(call.callee)) {
+        visit(call.callee);
+        low.set(ip, Math.min(low.get(ip), low.get(call.callee)));
+      } else if (on.has(call.callee)) low.set(ip, Math.min(low.get(ip), index.get(call.callee)));
+    }
+    if (low.get(ip) !== index.get(ip)) return;
+    const component = [];
+    for (; ; ) {
+      const member = stack.pop();
+      on.delete(member);
+      component.push(member);
+      if (member === ip) break;
+    }
+    if (component.length > 1 || component.some((member) => fns.get(member).calls.some((c) => c.callee === member))) {
+      for (const member of component) recursive.add(member);
+    }
+  };
+  for (const ip of fns.keys()) if (!index.has(ip)) visit(ip);
+  return recursive;
+}
+function fallback(emitted, reason, before) {
+  return {
+    ...emitted,
+    supercompile: {
+      ...before,
+      activated: false,
+      reason,
+      functionsAfter: before.functionsBefore,
+      pieceCallsAfter: before.pieceCallsBefore,
+      sourceAfter: before.sourceBefore,
+      regions: before.functionsBefore,
+      largestRegionSource: 0,
+      protocolRegions: { node: 0, repv: 0, nodeAndRepv: 0 }
+    }
+  };
+}
+function supercompileRuleMapReplacement(prog, replacement) {
+  const cfg = defaultAssemblyCfgs(prog)[0];
+  if (cfg === void 0) return replacement;
+  const extraIps = [];
+  for (const scan of prog.scans ?? []) {
+    for (const ref2 of scan.skip) extraIps.push(ref2[0]);
+    if (scan.sentinel !== void 0) extraIps.push(scan.sentinel[0]);
+  }
+  for (const set of prog.scanSkip ?? []) for (const ref2 of set) extraIps.push(ref2[0]);
+  let canonical2;
+  let candidate;
+  try {
+    canonical2 = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true);
+    candidate = supercompileEmittedAssembly(prog, cfg, extraIps, canonical2);
+  } catch {
+    return replacement;
+  }
+  if (!candidate.supercompile.activated) return replacement;
+  const prefix = "const __parseman_macro_replacement__=";
+  const parsed = parseSync4("parseman-entry-supercompile-replacement.js", prefix + replacement);
+  if (parsed.errors.length > 0) return replacement;
+  const program = parsed.program;
+  const declaration = nodes(program.body)[0];
+  const declarator = nodes(declaration?.declarations)[0];
+  const call = ast(declarator?.init);
+  const table = nodes(call?.arguments)[0];
+  if (declaration?.type !== "VariableDeclaration" || declarator?.type !== "VariableDeclarator" || call?.type !== "CallExpression" || table?.type !== "ObjectExpression") return replacement;
+  const property = (object, key) => nodes(object.properties).find((prop) => prop.type === "Property" && nameOf(ast(prop.key)) === key);
+  const assembliesProp = property(table, "a");
+  const assemblies = nodes(ast(assembliesProp?.value)?.elements);
+  if (assembliesProp === void 0 || assemblies.length !== 1 || assemblies[0]?.type !== "ObjectExpression") return replacement;
+  const factoryProp = property(assemblies[0], "factory");
+  const factory = ast(factoryProp?.value);
+  const body = ast(factory?.body);
+  if (factory?.type !== "FunctionExpression" || body?.type !== "BlockStatement") return replacement;
+  if (typeof body.start !== "number" || typeof body.end !== "number") return replacement;
+  const start = body.start - prefix.length + 1;
+  const end = body.end - prefix.length - 1;
+  if (replacement.slice(start, end) !== canonical2.source + "\n") return replacement;
+  const transformed = replacement.slice(0, start) + candidate.source + "\n" + replacement.slice(end);
+  const checked = parseSync4("parseman-entry-supercompile-replacement-result.js", prefix + transformed);
+  return checked.errors.length === 0 ? transformed : replacement;
+}
+function supercompileEmittedAssembly(prog, _cfg, extraIps, emitted) {
+  const source = emitted.source;
+  const parsed = parseSync4("parseman-entry-supercompile.js", WRAP + source + SUFFIX);
+  if (parsed.errors.length > 0) {
+    const zero = { functionsBefore: 0, pieceCallsBefore: 0, sourceBefore: source.length, barriers: {} };
+    return fallback(emitted, "canonical emitted source did not parse", zero);
+  }
+  const program = parsed.program;
+  const wrapper = nodes(program.body)[0];
+  const wrapperBody = ast(wrapper?.body);
+  if (wrapper?.type !== "FunctionDeclaration" || wrapperBody?.type !== "BlockStatement") {
+    const zero = { functionsBefore: 0, pieceCallsBefore: 0, sourceBefore: source.length, barriers: {} };
+    return fallback(emitted, "missing compiler wrapper", zero);
+  }
+  const fns = /* @__PURE__ */ new Map();
+  for (const statement of nodes(wrapperBody.body)) {
+    if (statement.type !== "FunctionDeclaration") continue;
+    const name = nameOf(ast(statement.id));
+    const hit = name === void 0 ? void 0 : PIECE.exec(name);
+    const body = ast(statement.body);
+    if (hit !== void 0 && hit !== null && body?.type === "BlockStatement") {
+      const ip = Number(hit[1]);
+      fns.set(ip, { ip, name, node: statement, body, calls: [] });
+    }
+  }
+  const externalRefs = /* @__PURE__ */ new Set();
+  let reservedCollision = false;
+  const allCalls = [];
+  const walk = (node2, current, parent, statement, statementParent) => {
+    if (isFunction(node2) && node2 !== current?.node) {
+      const own = node2.type === "FunctionDeclaration" ? nameOf(ast(node2.id)) : void 0;
+      const hit = own === void 0 ? void 0 : PIECE.exec(own);
+      if (hit !== void 0 && hit !== null) {
+        const fn = fns.get(Number(hit[1]));
+        if (fn !== void 0) {
+          for (const child of children2(node2)) {
+            if (child !== ast(node2.id)) walk(child, fn, node2, void 0, void 0);
+          }
+          return;
+        }
+      }
+      current = void 0;
+    }
+    let owner2 = statement;
+    let ownerParent = statementParent;
+    if (parent?.type === "BlockStatement" && nodes(parent.body).includes(node2)) {
+      owner2 = node2;
+      ownerParent = parent;
+    }
+    if (parent?.type === "SwitchCase" && nodes(parent.consequent).includes(node2)) {
+      owner2 = node2;
+      ownerParent = parent;
+    }
+    if (node2.type === "CallExpression") {
+      const calleeName = nameOf(ast(node2.callee));
+      const hit = calleeName === void 0 ? void 0 : PIECE.exec(calleeName);
+      if (hit !== void 0 && hit !== null) {
+        const callee = Number(hit[1]);
+        const args = nodes(node2.arguments);
+        const transformable = current !== void 0 && owner2 !== void 0 && args.length === 3 && nameOf(args[0]) === "input" && nameOf(args[2]) === "ctx" && isDirectCallUse(node2, parent, owner2) && isListStatement(owner2, ownerParent);
+        if (current === void 0 || owner2 === void 0) externalRefs.add(callee);
+        else {
+          const call = { caller: current.ip, callee, node: node2, statement: owner2, args, transformable };
+          current.calls.push(call);
+          allCalls.push(call);
+        }
+      }
+    }
+    if (node2.type === "Identifier") {
+      if (typeof node2.name === "string" && /^_z\d/.test(node2.name)) reservedCollision = true;
+      const hit = typeof node2.name === "string" ? PIECE.exec(node2.name) : null;
+      if (hit !== null) {
+        const isDecl = parent?.type === "FunctionDeclaration" && parent.id === node2;
+        const isCall = parent?.type === "CallExpression" && parent.callee === node2;
+        if (!isDecl && !isCall) externalRefs.add(Number(hit[1]));
+      }
+    }
+    for (const child of children2(node2)) walk(child, current, node2, owner2, ownerParent);
+  };
+  for (const statement of nodes(wrapperBody.body)) walk(statement, void 0, wrapperBody, void 0, void 0);
+  if (reservedCollision) {
+    const before2 = { functionsBefore: fns.size, pieceCallsBefore: allCalls.length, sourceBefore: source.length, barriers: { name: 1 } };
+    return fallback(emitted, "canonical source uses the reserved _z<N> supercompiler prefix", before2);
+  }
+  const pieceCallsBefore = allCalls.length;
+  const recursive = recursiveMembers(fns);
+  const incoming = /* @__PURE__ */ new Map();
+  for (const call of allCalls) {
+    const list = incoming.get(call.callee) ?? [];
+    list.push(call);
+    incoming.set(call.callee, list);
+  }
+  const publicRoots = /* @__PURE__ */ new Set([...Object.values(prog.rules), ...extraIps]);
+  const barrier = /* @__PURE__ */ new Map();
+  for (const ip of fns.keys()) {
+    if (publicRoots.has(ip) || externalRefs.has(ip)) barrier.set(ip, "public");
+    else if (recursive.has(ip)) barrier.set(ip, "recursive");
+    else if (prog.code[ip] === OP_ATTEMPT || prog.code[ip] === OP_SCAN) barrier.set(ip, "effect");
+    else if (hasInlineScopeHazard(fns.get(ip))) barrier.set(ip, "scope");
+    else if (!hasInlineSignature(fns.get(ip))) barrier.set(ip, "shape");
+    else if ((incoming.get(ip)?.length ?? 0) !== 1) barrier.set(ip, "shared");
+    else if (!incoming.get(ip)[0].transformable) barrier.set(ip, "shape");
+  }
+  const roots = [...fns.keys()].filter((ip) => barrier.has(ip));
+  const owner = /* @__PURE__ */ new Map();
+  const absorb = (ip, root) => {
+    if (owner.has(ip)) return;
+    owner.set(ip, root);
+    for (const call of fns.get(ip)?.calls ?? []) {
+      if (!fns.has(call.callee) || barrier.has(call.callee) || !call.transformable) continue;
+      absorb(call.callee, root);
+    }
+  };
+  for (const root of roots) absorb(root, root);
+  for (const ip of fns.keys()) if (!owner.has(ip)) {
+    barrier.set(ip, "shared");
+    absorb(ip, ip);
+  }
+  let serial = 0;
+  const src = (node2) => {
+    const r = range(node2);
+    return source.slice(r.start, r.end);
+  };
+  const renderBody = (ip, embedded) => {
+    const fn = fns.get(ip);
+    const bodyRange = range(fn.body);
+    const start = bodyRange.start + 1;
+    const end = bodyRange.end - 1;
+    const edits = [];
+    const callsByStatement = /* @__PURE__ */ new Map();
+    for (const call of fn.calls) {
+      if (owner.get(call.callee) !== owner.get(ip) || barrier.has(call.callee) || !call.transformable) continue;
+      const list = callsByStatement.get(call.statement) ?? [];
+      list.push(call);
+      callsByStatement.set(call.statement, list);
+    }
+    const returns = [];
+    const collectReturns = (node2) => {
+      if (node2 !== fn.body && isFunction(node2)) return;
+      if (node2.type === "ReturnStatement") returns.push(node2);
+      for (const child of children2(node2)) collectReturns(child);
+    };
+    if (embedded !== void 0) collectReturns(fn.body);
+    const callPrefix = (call) => {
+      const id = serial++;
+      const result = `_z${id}r`;
+      const label2 = `_z${id}`;
+      const at = `_z${id}p`;
+      const nested = renderBody(call.callee, { result, label: label2 });
+      return {
+        value: result,
+        prefix: `let ${result},${at}=${src(call.args[1])}
+${label2}:{let pos=${at}
+${nested}
+}
+`
+      };
+    };
+    for (const [statement, calls] of callsByStatement) {
+      let prefix = "";
+      const replacements = [];
+      for (const call of calls) {
+        const made = callPrefix(call);
+        prefix += made.prefix;
+        const cr = range(call.node);
+        replacements.push({ start: cr.start, end: cr.end, text: made.value });
+      }
+      if (statement.type === "ReturnStatement" && embedded !== void 0) {
+        const sr = range(statement);
+        const arg = ast(statement.argument);
+        const value = arg === void 0 ? "undefined" : render2(source, range(arg).start, range(arg).end, replacements);
+        edits.push({ start: sr.start, end: sr.end, text: `{${prefix}${embedded.result}=${value};break ${embedded.label}}` });
+      } else {
+        const sr = range(statement);
+        edits.push({ start: sr.start, end: sr.start, text: prefix });
+        edits.push(...replacements);
+      }
+    }
+    if (embedded !== void 0) {
+      for (const statement of returns) {
+        if (callsByStatement.has(statement)) continue;
+        const sr = range(statement);
+        const arg = ast(statement.argument);
+        edits.push({
+          start: sr.start,
+          end: sr.end,
+          text: `{${embedded.result}=${arg === void 0 ? "undefined" : src(arg)};break ${embedded.label}}`
+        });
+      }
+    }
+    return render2(source, start, end, edits);
+  };
+  const regionSizes = /* @__PURE__ */ new Map();
+  const regionProtocol = /* @__PURE__ */ new Map();
+  for (const [ip, root] of owner) {
+    const r = range(fns.get(ip).node);
+    regionSizes.set(root, (regionSizes.get(root) ?? 0) + r.end - r.start);
+    const op = prog.code[ip];
+    const bits = (op === OP_NODE || op === OP_NODE_TRACK ? 1 : 0) | (op === OP_REPV ? 2 : 0);
+    regionProtocol.set(root, (regionProtocol.get(root) ?? 0) | bits);
+  }
+  const oversized = /* @__PURE__ */ new Set();
+  for (const [ip, size] of regionSizes) if (size > 18e4) oversized.add(ip);
+  if (oversized.size > 0) {
+    const counts2 = Object.fromEntries([...barrier.values()].map((k) => [k, 0]));
+    for (const kind of barrier.values()) counts2[kind] = (counts2[kind] ?? 0) + 1;
+    const before2 = { functionsBefore: fns.size, pieceCallsBefore, sourceBefore: source.length, barriers: counts2 };
+    return fallback(emitted, "a region exceeded the 180KB source cap", before2);
+  }
+  const topEdits = [];
+  for (const [ip, fn] of fns) {
+    if (owner.get(ip) === ip) {
+      const br = range(fn.body);
+      topEdits.push({ start: br.start + 1, end: br.end - 1, text: renderBody(ip, void 0) });
+    } else {
+      const fr = range(fn.node);
+      topEdits.push({ start: fr.start, end: fr.end, text: "" });
+    }
+  }
+  const candidate = render2(source, 0, source.length, topEdits);
+  const counts = {};
+  for (const kind of barrier.values()) counts[kind] = (counts[kind] ?? 0) + 1;
+  const before = { functionsBefore: fns.size, pieceCallsBefore, sourceBefore: source.length, barriers: counts };
+  if (candidate.length > Math.ceil(source.length * 1.05)) {
+    return fallback(emitted, `candidate exceeded the 5% total source cap (${candidate.length} > ${Math.ceil(source.length * 1.05)})`, before);
+  }
+  const functionsAfter = roots.length;
+  const removed = fns.size - functionsAfter;
+  const checked = parseSync4("parseman-entry-supercompile-result.js", WRAP + candidate + SUFFIX);
+  if (checked.errors.length > 0) return fallback(emitted, "structured candidate did not parse", before);
+  const declared = /* @__PURE__ */ new Set();
+  const referenced = /* @__PURE__ */ new Set();
+  const checkRefs = (node2, parent) => {
+    if (node2.type === "FunctionDeclaration") {
+      const name = nameOf(ast(node2.id));
+      if (name !== void 0 && PIECE.test(name)) declared.add(name);
+    }
+    if (node2.type === "Identifier" && typeof node2.name === "string" && PIECE.test(node2.name)) {
+      const isDeclaration = parent?.type === "FunctionDeclaration" && parent.id === node2;
+      if (!isDeclaration) referenced.add(node2.name);
+    }
+    for (const child of children2(node2)) checkRefs(child, node2);
+  };
+  checkRefs(checked.program);
+  if (declared.size !== functionsAfter || [...referenced].some((name) => !declared.has(name))) {
+    return fallback(emitted, "deleted piece body remains reachable after structured relinking", before);
+  }
+  const largestRegion = [...regionSizes].sort((a, b) => b[1] - a[1])[0];
+  const protocolRegions = {
+    node: [...regionProtocol.values()].filter((bits) => (bits & 1) !== 0).length,
+    repv: [...regionProtocol.values()].filter((bits) => (bits & 2) !== 0).length,
+    nodeAndRepv: [...regionProtocol.values()].filter((bits) => bits === 3).length
+  };
+  return {
+    ...emitted,
+    source: candidate,
+    supercompile: {
+      ...before,
+      activated: removed > 0,
+      ...removed > 0 ? {} : { reason: "no uniquely-owned region bodies" },
+      functionsAfter,
+      pieceCallsAfter: pieceCallsBefore - removed,
+      sourceAfter: candidate.length,
+      regions: roots.length,
+      largestRegionSource: Math.max(0, ...regionSizes.values()),
+      ...largestRegion === void 0 ? {} : { largestRegionIp: largestRegion[0] },
+      protocolRegions
+    }
+  };
+}
+
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var TABLE_RUNTIME_SPECIFIER = "parseman/table";
@@ -17669,7 +19238,7 @@ function parseModuleCached(filePath) {
   let parsed = null;
   try {
     const src = fs2.readFileSync(filePath, "utf8");
-    const r = parseSync4(filePath, src);
+    const r = parseSync5(filePath, src);
     if (r.errors.length === 0) parsed = { body: r.program.body, src };
   } catch {
   }
@@ -17818,7 +19387,7 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
     const source = fs2.readFileSync(file, "utf8");
     const transformed = transformMacro(source, file, moduleAliases, warnUnloweredRegex, recovery);
     if (!transformed || transformed.warnings.length > 0) return null;
-    const parsed = parseSync4(file, transformed.code);
+    const parsed = parseSync5(file, transformed.code);
     parsedModule = parsed.errors.length === 0 ? { body: parsed.program.body, src: transformed.code } : null;
     return parsedModule;
   } catch {
@@ -17841,7 +19410,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
 function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage) {
   let result;
   try {
-    result = parseSync4(id, code);
+    result = parseSync5(id, code);
   } catch {
     return null;
   }
@@ -18462,9 +20031,12 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
         if (compiled !== null) {
           usedTableRuntime = true;
           return {
-            replacement: compiled.replacementWithMetadata(
-              staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
-              { precompileDefault: true }
+            replacement: supercompileRuleMapReplacement(
+              compiled.prog,
+              compiled.replacementWithMetadata(
+                staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
+                { precompileDefault: true }
+              )
             ),
             ...importedFactories.length ? { importedFactories } : {}
           };