parseman 0.49.0 → 0.50.1

package/dist/cli/index.js

@@ -927,7 +927,7 @@ 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 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 };
 }
@@ -959,7 +959,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;
@@ -973,6 +974,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;
   }
@@ -1032,19 +1034,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);
@@ -2476,6 +2496,13 @@ function canConsumeNewline(n) {
       return n.parts.some(canConsumeNewline);
   }
 }
+function regexCanMatchEmpty(source) {
+  try {
+    return nullable(parseRegex(source));
+  } catch {
+    return true;
+  }
+}
 function firstSetFromRegex(source) {
   let ast;
   try {
@@ -4923,6 +4950,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;
@@ -5479,7 +5507,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(", ")}`);
     }
@@ -5489,6 +5517,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;
   };
@@ -5621,6 +5650,301 @@ function evalRuleMapIR(ir) {
   return Object.entries(map);
 }
 
+// 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 mayCommitFailure(p, seen = /* @__PURE__ */ new Set(), resolve2) {
+  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, resolve2));
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+      return mayCommitFailure(d.parser, seen, resolve2);
+    case "sepBy":
+      return mayCommitFailure(d.parser, seen, resolve2) || mayCommitFailure(d.separator, seen, resolve2);
+    case "token":
+    case "leaf":
+      return mayCommitFailure(d.parser, seen, resolve2);
+    case "withCtx":
+      return mayCommitFailure(d.parser, seen, resolve2);
+    case "scanTo":
+      return mayCommitFailure(d.sentinel, seen, resolve2) || d.skip.some((x) => mayCommitFailure(x, seen, resolve2));
+    case "lazy": {
+      try {
+        return mayCommitFailure(d.thunk(), seen, resolve2);
+      } catch {
+        const name = p._ruleName;
+        const target = name === void 0 ? void 0 : resolve2?.(name);
+        return target === void 0 ? true : mayCommitFailure(target, seen, resolve2);
+      }
+    }
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+
 // src/table/ops.ts
 var OP_LIT = 1;
 var OP_RX = 2;
@@ -6176,8 +6500,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;
@@ -6352,7 +6694,6 @@ function directArrayProjection(fn, fnSrc, arity) {
 
 // src/table/encode.ts
 import {
-  assertLexicalCapabilityClosure,
   collectLexicalCapabilities,
   winnerWrapsReference as winnerWrapsReference2
 } from "../compiler/token-capability.js";
@@ -6734,6 +7075,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;
@@ -7144,6 +7504,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 childrenOf(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(fs) {
     if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
@@ -7429,9 +7855,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;
@@ -7440,6 +7896,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":
@@ -7469,8 +7929,11 @@ var Encoder = class {
         }
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, 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)) {
@@ -7629,6 +8092,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 fs = d.parser._meta.firstSet;
         if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
         const cls = this.charClass(fs);
@@ -7797,6 +8261,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
     });
   }
 };
@@ -7841,7 +8309,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]);
@@ -8974,13 +9441,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();
@@ -9003,25 +9474,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;
 }
@@ -9088,6 +9560,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 {
@@ -9169,6 +9797,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)
@@ -9234,6 +9872,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);
 }
@@ -9246,11 +9918,12 @@ function sinkReads(t2, s) {
 ${t2}fd=ctx._fields!==undefined?ctx._fields.length:0` : ""}${s.er ? `
 ${t2}er=ctx._errors!==undefined?ctx._errors.length:0` : ""}`;
 }
-function emitMark(t2, buf, s = NO_SINKS, decl = true) {
+function emitMark(t2, buf, rawMode, s = NO_SINKS, decl = true) {
   if (buf) {
+    const raw = rawMode === RAW_OMIT ? `${t2}raw=b.rawLen` : rawMode === RAW_CAPTURE ? `const r=b.raw;${t2}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0` : `const r=b.raw;${t2}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)`;
     return `${decl ? `let ${t2}raw=0,${t2}tl=0,${t2}lv=0,${t2}lg=0,${t2}rt=0${sinkSlots(t2, s)}
 ` : ""}{const b=ctx._cstBuf
-const r=b.raw;${t2}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+${raw}
 const h=b.ch;${t2}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${t2}tl=l!==undefined?l.length:0
 ${t2}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
@@ -9260,7 +9933,7 @@ ${t2}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t2
 ` : `${t2}n=false
 `}{const b=ctx._cstBuf
 if(b!==undefined){
-const r=b.raw;${t2}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const r=b.raw;${t2}raw=b.noRaw===true?b.rawLen:(r!==undefined?r.length:b.rawSingle!==undefined?1:0)
 const h=b.ch;${t2}lv=h!==undefined?h.length:b.single!==undefined?1:0
 const l=b.tl;${t2}tl=l!==undefined?l.length:0
 ${t2}n=true
@@ -9275,14 +9948,16 @@ ${t2}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${t2}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${sinkReads(t2, s)}
 }}`;
 }
-function emitRollback(t2, buf, s = NO_SINKS) {
+function emitRollback(t2, buf, rawMode, s = NO_SINKS) {
   const fd = s.fd ? `
 if(ctx._fields!==undefined&&ctx._fields.length!==${t2}fd)ctx._fields.length=${t2}fd` : "";
   const er = s.er ? `
 if(ctx._errors!==undefined&&ctx._errors.length!==${t2}er)ctx._errors.length=${t2}er` : "";
-  if (buf) return `_rbBuf(ctx,${t2}raw,${t2}tl,${t2}lv,${t2}lg,${t2}rt)${fd}${er}`;
-  if (!s.fd && !s.er) return `if(${t2}n)rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,0,undefined,${t2}lg,${t2}rt)`;
-  return `if(${t2}n){rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,${s.fd ? `${t2}fd` : "0"},${s.er ? `${t2}er` : "undefined"},${t2}lg,${t2}rt)}`;
+  if (buf && rawMode === RAW_OMIT) return `_rbNoRawBuf(ctx,${t2}raw,${t2}tl,${t2}lv,${t2}lg,${t2}rt)${fd}${er}`;
+  if (buf && rawMode === RAW_CAPTURE) return `_rbBuf(ctx,${t2}raw,${t2}tl,${t2}lv,${t2}lg,${t2}rt)${fd}${er}`;
+  if (buf) return `rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,${s.fd ? `${t2}fd` : "undefined"},${s.er ? `${t2}er` : "undefined"},${t2}lg,${t2}rt)`;
+  if (!s.fd && !s.er) return `if(${t2}n)rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,undefined,undefined,${t2}lg,${t2}rt)`;
+  return `if(${t2}n){rollbackTriviaAt(ctx,${t2}raw,${t2}tl,${t2}lv,${s.fd ? `${t2}fd` : "undefined"},${s.er ? `${t2}er` : "undefined"},${t2}lg,${t2}rt)}`;
 }
 function emitTerm(callee, dst, t2, l, skip) {
   const fast = `const ${t2}v=${callee}(input,cur,ctx)
@@ -9340,37 +10015,111 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t2, prog, cfg, extraIps = []) {
-  const { code, k, disp, dsp, triviaLabelled } = t2;
+function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
+  const { code, k, fx, disp, dsp, triviaLabelled } = t2;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC = 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 && t2.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 = REC;
-    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 || REC && (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();
@@ -9397,9 +10146,117 @@ function emitAssemblySource(t2, 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;
@@ -9487,7 +10344,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}`;
@@ -9738,20 +10596,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
@@ -9807,12 +10669,13 @@ return v
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
+        const clean = !REC && 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
@@ -9835,9 +10698,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}
@@ -9849,9 +10712,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
@@ -9859,14 +10722,15 @@ return null
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const clean = !REC && 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
 }
@@ -9965,57 +10829,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 = REC ? -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 gate = 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(${gate}){
+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
 }`;
         }
@@ -10034,30 +11034,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))
@@ -10065,33 +11043,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
 }
@@ -10127,23 +11115,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{
@@ -10250,7 +11240,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
 }`;
@@ -10272,7 +11262,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}
@@ -10282,6 +11287,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))
@@ -10320,6 +11326,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})`;
@@ -10333,7 +11340,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
@@ -10344,7 +11356,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
@@ -10378,7 +11393,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
 }`;
@@ -10396,7 +11411,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")}
@@ -10411,7 +11426,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]
@@ -10635,6 +11656,17 @@ function assemble(t2, 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();
@@ -10880,7 +11912,7 @@ function assemble(t2, 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;
@@ -10964,6 +11996,31 @@ function assemble(t2, 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;
   }
@@ -11234,7 +12291,8 @@ function assemble(t2, 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);
@@ -11977,6 +13035,7 @@ function assemble(t2, 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);
@@ -12031,7 +13090,7 @@ function assemble(t2, 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;
@@ -12116,7 +13175,7 @@ function assemble(t2, 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];
@@ -12205,7 +13264,7 @@ function assemble(t2, 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 });
@@ -12215,7 +13274,7 @@ function assemble(t2, 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];
@@ -12224,7 +13283,7 @@ function assemble(t2, 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;
@@ -12236,10 +13295,10 @@ function assemble(t2, 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 });
@@ -12249,10 +13308,10 @@ function assemble(t2, 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];
@@ -12261,9 +13320,9 @@ function assemble(t2, 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;
@@ -12271,43 +13330,43 @@ function assemble(t2, 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);
@@ -12478,6 +13537,13 @@ function assemble(t2, 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 && !REC && !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;
@@ -12507,7 +13573,10 @@ function assemble(t2, 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;
@@ -12570,7 +13639,7 @@ function assemble(t2, 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;
@@ -12586,7 +13655,7 @@ function assemble(t2, 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;
@@ -12603,7 +13672,7 @@ function assemble(t2, 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;
@@ -13176,20 +14245,14 @@ function assemble(t2, 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;
@@ -13204,13 +14267,9 @@ function assemble(t2, 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;
@@ -13301,6 +14360,34 @@ function assemble(t2, 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);
@@ -13711,7 +14798,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t2, prog, cfg, extraIps);
+      em = emitAssemblySource(t2, prog, cfg, extraIps, true);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -16086,7 +17173,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]));
@@ -16550,6 +17637,7 @@ function rebuildCombinator(root, replacements) {
           return p;
         }
         out = d.type === void 0 ? d.build === void 0 ? node(one(d.parser), opts) : node(one(d.parser), d.build) : node(d.type, one(d.parser), d.build, opts);
+        if (d.buildRawUnused === true && out._def.tag === "node") out._def.buildRawUnused = true;
         break;
       }
       case "grammar": {