parseman 0.49.0 → 0.50.1

package/dist/analysis/diagnostics.js

@@ -405,7 +405,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 };
 }
@@ -437,7 +437,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;
@@ -451,6 +452,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;
   }
@@ -510,19 +512,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);
@@ -2620,222 +2640,780 @@ function analyzeChoice(p, d, rule2, resolve) {
   };
 }
 
-// src/recovery/scan.ts
-function probeAt(sentinel, input, pos, ctx) {
-  const s = {
-    _probe: ctx._probe,
-    _errors: ctx._errors,
-    _cstLeaves: ctx._cstLeaves,
-    _cstChildren: ctx._cstChildren,
-    _cstRawChildren: ctx._cstRawChildren,
-    _cstTriviaLog: ctx._cstTriviaLog,
-    _triviaLog: ctx._triviaLog,
-    _rootTriviaLog: ctx._rootTriviaLog,
-    _fields: ctx._fields,
-    _cstBuf: ctx._cstBuf,
-    _tolerant: ctx._tolerant,
-    _sync: ctx._sync
-  };
-  ctx._probe = void 0;
-  ctx._errors = void 0;
-  ctx._cstLeaves = void 0;
-  ctx._cstChildren = void 0;
-  ctx._cstRawChildren = void 0;
-  ctx._cstTriviaLog = void 0;
-  ctx._triviaLog = void 0;
-  ctx._rootTriviaLog = void 0;
-  ctx._fields = void 0;
-  ctx._cstBuf = void 0;
-  ctx._tolerant = void 0;
-  ctx._sync = void 0;
-  try {
-    return sentinel.parse(input, pos, ctx).ok;
-  } finally {
-    ctx._probe = s._probe;
-    ctx._errors = s._errors;
-    ctx._cstLeaves = s._cstLeaves;
-    ctx._cstChildren = s._cstChildren;
-    ctx._cstRawChildren = s._cstRawChildren;
-    ctx._cstTriviaLog = s._cstTriviaLog;
-    ctx._triviaLog = s._triviaLog;
-    ctx._rootTriviaLog = s._rootTriviaLog;
-    ctx._fields = s._fields;
-    ctx._cstBuf = s._cstBuf;
-    ctx._tolerant = s._tolerant;
-    ctx._sync = s._sync;
-  }
-}
-function orSentinel(a, b) {
-  if (b === void 0) return a;
-  return {
-    _tag: "orSentinel",
-    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos, ctx) {
-      const ra = a.parse(input, pos, ctx);
-      if (ra.ok) return ra;
-      return b.parse(input, pos, ctx);
-    }
-  };
-}
-function firstSetSentinel(fs) {
-  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
-  const ranges = fs.ranges;
-  return {
-    _tag: "firstSetSentinel",
-    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },
-    _def: { tag: "unknown" },
-    parse(input, pos) {
-      const code = pos < input.length ? input.codePointAt(pos) : void 0;
-      if (code !== void 0) {
-        for (const r of ranges) {
-          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
-        }
-      }
-      return { ok: false, expected: [], span: { start: pos, end: pos } };
-    }
-  };
-}
-function recoverScan(input, from, ctx, sync, expected) {
-  let scanPos = from;
-  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
-  const span = { start: from, end: scanPos };
-  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
-  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-  ctx._errors?.push(error);
-  return { error, end: scanPos };
-}
-function matchesAt(sentinel, input, pos, ctx) {
-  return probeAt(sentinel, input, pos, ctx);
+// src/regex/first-set.ts
+var ANY = { t: "any" };
+var EMPTY2 = { t: "empty" };
+function charNode(set, nl) {
+  return { t: "char", set, nl };
 }
-function captureError(ctx, error) {
-  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+function rangesToSet(ranges) {
+  let fs = empty();
+  for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi));
+  return fs;
 }
-
-// src/combinators/expect.ts
-function deriveExpected(c) {
-  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+function rangesHaveNewline(ranges) {
+  return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
 }
-function derive(c, seen) {
-  const deriveExpected2 = (p) => derive(p, seen);
-  const def = c._def;
-  switch (def.tag) {
-    case "literal":
-      return [JSON.stringify(def.value)];
-    case "regex":
-      return [`/${def.source}/`];
-    case "keywords":
-      return def.words.map((w) => JSON.stringify(w));
-    case "label":
-      return [def.label];
-    case "choice":
-      return def.parsers.flatMap(deriveExpected2);
-    case "dispatch":
-      return deriveExpected2(def.selector);
-    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
-    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
-    // able to fail first — deriving from term 0 alone named a token the parse
-    // never actually required. A leading `not(…)` is zero-width and contributes
-    // nothing (its own expectation is about what must NOT be here), but it is
-    // nullable, so keep scanning past it. Stop at the first term that must match.
-    case "sequence": {
-      const out = [];
-      for (const term of def.parsers) {
-        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
-        if (!matchesEmpty(term)) break;
-      }
-      return out;
-    }
-    case "attempt":
-      return deriveExpected2(def.parser);
-    // Delegating wrappers whose first-token failure is their inner parser's — must
-    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
-    // node, which reads this) names the real expected token, not the wrapper tag.
-    case "field":
-    case "withCtx":
-    case "recover":
-      return deriveExpected2(def.parser);
-    case "expect":
-      return def.expected;
-    case "node":
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "transform":
-    case "not":
-    case "peek":
-      return deriveExpected2(def.parser);
-    // A bare routed() can only fail as "there is no routed token here". With a
-    // fallback, THAT is the branch that can fail, so its expectations are the useful
-    // ones — the routed path either succeeds or is not taken.
-    case "routed":
-      return def.fallback === void 0 ? ["routed()"] : deriveExpected2(def.fallback);
-    // A bare adjacency assertion names the JOIN it requires. Inside a sequence it is
-    // skipped entirely (isZeroWidthAssertion, above), which is the normal path.
-    case "adjacency":
-      return [def.polarity];
-    case "lazy": {
-      const name = c._ruleName;
-      if (seen.has(c)) return name ? [name] : [];
-      seen.add(c);
-      try {
-        return deriveExpected2(def.thunk());
-      } catch {
-        return name ? [name] : [];
-      } finally {
-        seen.delete(c);
-      }
+var BAIL = /* @__PURE__ */ Symbol("regex-bail");
+function parseRegex(src) {
+  let i = 0;
+  const parseAlt = () => {
+    const arms = [parseSeq()];
+    while (src[i] === "|") {
+      i++;
+      arms.push(parseSeq());
     }
-    default:
-      return [];
-  }
-}
-function expect(combinator, label2) {
-  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
-  const meta = {
-    firstSet: combinator._meta.firstSet,
-    canMatchNewline: combinator._meta.canMatchNewline,
-    isTrivia: false
+    return arms.length === 1 ? arms[0] : { t: "alt", arms };
   };
-  return {
-    _tag: "expect",
-    _meta: meta,
-    _def: { tag: "expect", parser: combinator, label: label2, expected },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (result.ok) return result;
-      const span = { start: pos, end: pos };
-      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
-      ctx._errors?.push(error);
-      if (ctx._tolerant) captureError(ctx, error);
-      return { ok: true, value: error, span: { start: pos, end: pos } };
+  const parseSeq = () => {
+    const parts = [];
+    while (i < src.length) {
+      const ch2 = src[i];
+      if (ch2 === "|" || ch2 === ")") break;
+      parts.push(parseQuantified());
     }
+    if (parts.length === 0) return EMPTY2;
+    return parts.length === 1 ? parts[0] : { t: "seq", parts };
   };
-}
-
-// src/combinators/choice.ts
-function choice(...args) {
-  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
-  const gates = args.map((a) => "gate" in a ? a.gate : null);
-  const hasGates = gates.some((g) => g !== null);
-  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
-  let combined = { kind: "empty" };
-  for (const p of parsers) combined = union(combined, p._meta.firstSet);
-  const meta = {
-    firstSet: combined,
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false,
-    disjoint
+  const parseQuantified = () => {
+    const atom = parseAtom();
+    const ch2 = src[i];
+    let min = null;
+    if (ch2 === "*") {
+      min = 0;
+      i++;
+    } else if (ch2 === "+") {
+      min = 1;
+      i++;
+    } else if (ch2 === "?") {
+      min = 0;
+      i++;
+    } else if (ch2 === "{") {
+      min = parseBraceQuantifier();
+    }
+    if (min === null) return atom;
+    if (src[i] === "?") i++;
+    return { t: "rep", node: atom, min };
   };
-  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
-  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
-  let greedyLitMap = null;
-  let sortedParsers = null;
-  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
+  const parseBraceQuantifier = () => {
+    const close = src.indexOf("}", i);
+    if (close === -1) return null;
+    const m = /^(\d+)(?:,(\d*))?$/.exec(src.slice(i + 1, close));
+    if (!m) return null;
+    i = close + 1;
+    return Number.parseInt(m[1], 10);
+  };
+  const parseAtom = () => {
+    const ch2 = src[i];
+    switch (ch2) {
+      case "(":
+        return parseGroup();
+      case "[":
+        return parseClass();
+      case ".":
+        i++;
+        return charNode(any(), false);
+      // `.` matches any char except line terminators
+      case "\\":
+        return parseEscape();
+      case "^":
+      case "$":
+        i++;
+        return EMPTY2;
+      // anchors are zero-width
+      case "{":
+        i++;
+        return charNode(fromRange(123, 123), false);
+      // a `{` with nothing to quantify is a literal brace
+      default:
+        i += ch2.length;
+        return charNode(fromRange(ch2.codePointAt(0), ch2.codePointAt(0)), ch2 === "\n");
+    }
+  };
+  const parseGroup = () => {
+    i++;
+    let lookaround = false;
+    if (src[i] === "?") {
+      const c1 = src[i + 1];
+      if (c1 === ":") i += 2;
+      else if (c1 === "=" || c1 === "!") {
+        i += 2;
+        lookaround = true;
+      } else if (c1 === "<") {
+        const c2 = src[i + 2];
+        if (c2 === "=" || c2 === "!") {
+          i += 3;
+          lookaround = true;
+        } else {
+          const gt = src.indexOf(">", i);
+          if (gt === -1) throw BAIL;
+          i = gt + 1;
+        }
+      } else throw BAIL;
+    }
+    const inner = parseAlt();
+    if (src[i] !== ")") throw BAIL;
+    i++;
+    return lookaround ? EMPTY2 : inner;
+  };
+  const parseClass = () => {
+    let k = i + 1;
+    const negated = src[k] === "^";
+    if (negated) k++;
+    let body = "";
+    while (k < src.length && src[k] !== "]") {
+      if (src[k] === "\\") {
+        body += src[k] + (src[k + 1] ?? "");
+        k += 2;
+      } else {
+        body += src[k];
+        k++;
+      }
+    }
+    if (src[k] !== "]") throw BAIL;
+    i = k + 1;
+    const ranges = parseClassRanges(body);
+    if (negated) return charNode(any(), !ranges || !rangesHaveNewline(ranges));
+    if (!ranges) return charNode(any(), true);
+    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
+  };
+  const parseEscape = () => {
+    const e = src[i + 1];
+    if (e === void 0) throw BAIL;
+    if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
+      i += 6;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
+      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16);
+      i += 4;
+      return charNode(fromRange(cp, cp), cp === 10);
+    }
+    i += 2;
+    switch (e) {
+      case "d":
+        return charNode(rangesToSet(shorthandRanges("d")), false);
+      case "w":
+        return charNode(rangesToSet(shorthandRanges("w")), false);
+      case "s":
+        return charNode(rangesToSet(shorthandRanges("s")), true);
+      case "D":
+      case "W":
+      case "S":
+        return charNode(any(), true);
+      // negated shorthand → widen
+      case "b":
+      case "B":
+        return EMPTY2;
+      // word boundary: zero-width
+      case "n":
+        return charNode(fromRange(10, 10), true);
+      case "r":
+        return charNode(fromRange(13, 13), false);
+      case "t":
+        return charNode(fromRange(9, 9), false);
+      case "f":
+        return charNode(fromRange(12, 12), false);
+      case "v":
+        return charNode(fromRange(11, 11), false);
+      case "0":
+        return charNode(fromRange(0, 0), false);
+      default:
+        if (e >= "1" && e <= "9") return ANY;
+        return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
+    }
+  };
+  const node2 = parseAlt();
+  if (i < src.length) throw BAIL;
+  return node2;
+}
+function nullable(n) {
+  switch (n.t) {
+    case "char":
+      return false;
+    case "any":
+      return true;
+    case "empty":
+      return true;
+    case "seq":
+      return n.parts.every(nullable);
+    case "alt":
+      return n.arms.some(nullable);
+    case "rep":
+      return n.min === 0 || nullable(n.node);
+  }
+}
+function firstSet(n) {
+  switch (n.t) {
+    case "char":
+      return n.set;
+    case "any":
+      return any();
+    case "empty":
+      return empty();
+    case "rep":
+      return firstSet(n.node);
+    case "alt": {
+      let fs = empty();
+      for (const arm of n.arms) fs = union(fs, firstSet(arm));
+      return fs;
+    }
+    case "seq": {
+      let fs = empty();
+      for (const part of n.parts) {
+        fs = union(fs, firstSet(part));
+        if (!nullable(part)) break;
+      }
+      return fs;
+    }
+  }
+}
+function canConsumeNewline(n) {
+  switch (n.t) {
+    case "char":
+      return n.nl;
+    case "any":
+      return true;
+    case "empty":
+      return false;
+    case "rep":
+      return canConsumeNewline(n.node);
+    case "alt":
+      return n.arms.some(canConsumeNewline);
+    case "seq":
+      return n.parts.some(canConsumeNewline);
+  }
+}
+function regexCanMatchEmpty(source) {
+  try {
+    return nullable(parseRegex(source));
+  } catch {
+    return true;
+  }
+}
+function firstSetFromRegex(source) {
+  let ast;
+  try {
+    ast = parseRegex(source);
+  } catch {
+    return { firstSet: any(), canMatchNewline: true };
+  }
+  if (nullable(ast)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast) };
+  return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
+}
+
+// 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(), resolve) {
+  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, resolve));
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+      return mayCommitFailure(d.parser, seen, resolve);
+    case "sepBy":
+      return mayCommitFailure(d.parser, seen, resolve) || mayCommitFailure(d.separator, seen, resolve);
+    case "token":
+    case "leaf":
+      return mayCommitFailure(d.parser, seen, resolve);
+    case "withCtx":
+      return mayCommitFailure(d.parser, seen, resolve);
+    case "scanTo":
+      return mayCommitFailure(d.sentinel, seen, resolve) || d.skip.some((x) => mayCommitFailure(x, seen, resolve));
+    case "lazy": {
+      try {
+        return mayCommitFailure(d.thunk(), seen, resolve);
+      } catch {
+        const name = p._ruleName;
+        const target = name === void 0 ? void 0 : resolve?.(name);
+        return target === void 0 ? true : mayCommitFailure(target, seen, resolve);
+      }
+    }
+    case "unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/recovery/scan.ts
+function probeAt(sentinel, input, pos, ctx) {
+  const s = {
+    _probe: ctx._probe,
+    _errors: ctx._errors,
+    _cstLeaves: ctx._cstLeaves,
+    _cstChildren: ctx._cstChildren,
+    _cstRawChildren: ctx._cstRawChildren,
+    _cstTriviaLog: ctx._cstTriviaLog,
+    _triviaLog: ctx._triviaLog,
+    _rootTriviaLog: ctx._rootTriviaLog,
+    _fields: ctx._fields,
+    _cstBuf: ctx._cstBuf,
+    _tolerant: ctx._tolerant,
+    _sync: ctx._sync
+  };
+  ctx._probe = void 0;
+  ctx._errors = void 0;
+  ctx._cstLeaves = void 0;
+  ctx._cstChildren = void 0;
+  ctx._cstRawChildren = void 0;
+  ctx._cstTriviaLog = void 0;
+  ctx._triviaLog = void 0;
+  ctx._rootTriviaLog = void 0;
+  ctx._fields = void 0;
+  ctx._cstBuf = void 0;
+  ctx._tolerant = void 0;
+  ctx._sync = void 0;
+  try {
+    return sentinel.parse(input, pos, ctx).ok;
+  } finally {
+    ctx._probe = s._probe;
+    ctx._errors = s._errors;
+    ctx._cstLeaves = s._cstLeaves;
+    ctx._cstChildren = s._cstChildren;
+    ctx._cstRawChildren = s._cstRawChildren;
+    ctx._cstTriviaLog = s._cstTriviaLog;
+    ctx._triviaLog = s._triviaLog;
+    ctx._rootTriviaLog = s._rootTriviaLog;
+    ctx._fields = s._fields;
+    ctx._cstBuf = s._cstBuf;
+    ctx._tolerant = s._tolerant;
+    ctx._sync = s._sync;
+  }
+}
+function orSentinel(a, b) {
+  if (b === void 0) return a;
+  return {
+    _tag: "orSentinel",
+    _meta: { firstSet: { kind: "any" }, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos, ctx) {
+      const ra = a.parse(input, pos, ctx);
+      if (ra.ok) return ra;
+      return b.parse(input, pos, ctx);
+    }
+  };
+}
+function firstSetSentinel(fs) {
+  if (fs.kind !== "ranges" || fs.ranges.length === 0) return null;
+  const ranges = fs.ranges;
+  return {
+    _tag: "firstSetSentinel",
+    _meta: { firstSet: fs, canMatchNewline: false, isTrivia: false },
+    _def: { tag: "unknown" },
+    parse(input, pos) {
+      const code = pos < input.length ? input.codePointAt(pos) : void 0;
+      if (code !== void 0) {
+        for (const r of ranges) {
+          if (code >= r.lo && code <= r.hi) return { ok: true, value: null, span: { start: pos, end: pos } };
+        }
+      }
+      return { ok: false, expected: [], span: { start: pos, end: pos } };
+    }
+  };
+}
+function recoverScan(input, from, ctx, sync, expected) {
+  let scanPos = from;
+  while (scanPos < input.length && !probeAt(sync, input, scanPos, ctx)) scanPos++;
+  const span = { start: from, end: scanPos };
+  if (ctx.trackLines) recordLineRangeFromContext(ctx, input, from, scanPos);
+  const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+  ctx._errors?.push(error);
+  return { error, end: scanPos };
+}
+function matchesAt(sentinel, input, pos, ctx) {
+  return probeAt(sentinel, input, pos, ctx);
+}
+function captureError(ctx, error) {
+  if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
+}
+
+// src/combinators/expect.ts
+function deriveExpected(c) {
+  return [...new Set(derive(c, /* @__PURE__ */ new Set()))];
+}
+function derive(c, seen) {
+  const deriveExpected2 = (p) => derive(p, seen);
+  const def = c._def;
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return def.words.map((w) => JSON.stringify(w));
+    case "label":
+      return [def.label];
+    case "choice":
+      return def.parsers.flatMap(deriveExpected2);
+    case "dispatch":
+      return deriveExpected2(def.selector);
+    // Union through the NULLABLE prefix, mirroring `sequenceFirstSet`. A leading
+    // `optional(…)`/`many(…)` can match nothing, so the term after it is equally
+    // able to fail first — deriving from term 0 alone named a token the parse
+    // never actually required. A leading `not(…)` is zero-width and contributes
+    // nothing (its own expectation is about what must NOT be here), but it is
+    // nullable, so keep scanning past it. Stop at the first term that must match.
+    case "sequence": {
+      const out = [];
+      for (const term of def.parsers) {
+        if (!isZeroWidthAssertion(term)) out.push(...deriveExpected2(term));
+        if (!matchesEmpty(term)) break;
+      }
+      return out;
+    }
+    case "attempt":
+      return deriveExpected2(def.parser);
+    // Delegating wrappers whose first-token failure is their inner parser's — must
+    // pass through so a start-failure (and the first-set-miss fast-path in attempt/
+    // node, which reads this) names the real expected token, not the wrapper tag.
+    case "field":
+    case "withCtx":
+    case "recover":
+      return deriveExpected2(def.parser);
+    case "expect":
+      return def.expected;
+    case "node":
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "transform":
+    case "not":
+    case "peek":
+      return deriveExpected2(def.parser);
+    // A bare routed() can only fail as "there is no routed token here". With a
+    // fallback, THAT is the branch that can fail, so its expectations are the useful
+    // ones — the routed path either succeeds or is not taken.
+    case "routed":
+      return def.fallback === void 0 ? ["routed()"] : deriveExpected2(def.fallback);
+    // A bare adjacency assertion names the JOIN it requires. Inside a sequence it is
+    // skipped entirely (isZeroWidthAssertion, above), which is the normal path.
+    case "adjacency":
+      return [def.polarity];
+    case "lazy": {
+      const name = c._ruleName;
+      if (seen.has(c)) return name ? [name] : [];
+      seen.add(c);
+      try {
+        return deriveExpected2(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      } finally {
+        seen.delete(c);
+      }
+    }
+    default:
+      return [];
+  }
+}
+function expect(combinator, label2) {
+  const expected = label2 !== void 0 ? [label2] : deriveExpected(combinator);
+  const meta = {
+    firstSet: combinator._meta.firstSet,
+    canMatchNewline: combinator._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "expect",
+    _meta: meta,
+    _def: { tag: "expect", parser: combinator, label: label2, expected },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (result.ok) return result;
+      const span = { start: pos, end: pos };
+      const error = { _tag: "parseError", span: ctx.trackLines ? annotateSpanFromLineContext(span, ctx) : span, expected };
+      ctx._errors?.push(error);
+      if (ctx._tolerant) captureError(ctx, error);
+      return { ok: true, value: error, span: { start: pos, end: pos } };
+    }
+  };
+}
+
+// src/combinators/choice.ts
+function choice(...args) {
+  const parsers = args.map((a) => "gate" in a ? a.combinator : a);
+  const gates = args.map((a) => "gate" in a ? a.gate : null);
+  const hasGates = gates.some((g) => g !== null);
+  const disjoint = areDisjoint(parsers.map((p) => p._meta.firstSet)) && parsers.every((p) => !matchesEmpty(p));
+  let combined = { kind: "empty" };
+  for (const p of parsers) combined = union(combined, p._meta.firstSet);
+  const meta = {
+    firstSet: combined,
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false,
+    disjoint
+  };
+  const strategy = disjoint || hasGates ? null : detectStrategy(parsers);
+  const autoNot = !disjoint && !hasGates && (strategy?.tag === "firstMatch" || strategy?.tag === "sharedPrefix") ? computeAutoNot(parsers) : parsers.map(() => null);
+  let greedyLitMap = null;
+  let sortedParsers = null;
+  const asciiDispatch = disjoint ? buildAsciiDispatch(parsers) : null;
   if (strategy?.tag === "greedyClassify") {
     greedyLitMap = /* @__PURE__ */ new Map();
     for (let i = 0; i < parsers.length; i++) {
@@ -3363,6 +3941,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;
@@ -4420,381 +4999,125 @@ function sepBy(combinator, separatorArg, opts = {}) {
         let sepPos = cur;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-          } else {
-            sepPos = advanceTrivia(input, cur, ctx);
-          }
-        }
-        const sep = separator.parse(input, sepPos, ctx);
-        if (!sep.ok) {
-          rollbackTrivia(ctx, loopMark);
-          if (sep.committed) return sep;
-          break;
-        }
-        if (!keepSeparators) demoteCapturedToRaw(ctx, loopMark.leaves);
-        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
-        let nextPos = sep.span.end;
-        if (ctx.trivia) {
-          if (needsDeferredTriviaCommit(ctx)) {
-            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
-          } else {
-            nextPos = advanceTrivia(input, sep.span.end, ctx);
-          }
-        }
-        const next = combinator.parse(input, nextPos, ctx);
-        if (!next.ok) {
-          if (next.committed) return next;
-          const term = ctx._tolerant ? ctx._sync : void 0;
-          if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
-            expected ??= deriveExpected(combinator);
-            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected);
-            values.push(rec.error);
-            captureError(ctx, rec.error);
-            cur = rec.end;
-            continue;
-          }
-          if (sepMark !== void 0) {
-            rollbackTrivia(ctx, sepMark);
-            cur = sep.span.end;
-            break;
-          }
-          rollbackTrivia(ctx, loopMark);
-          break;
-        }
-        values.push(next.value);
-        cur = next.span.end;
-      }
-      if (values.length < min) return failAt2(cur);
-      return { ok: true, value: values, span: { start: pos, end: cur } };
-    }
-  };
-}
-
-// src/combinators/map.ts
-function transform(combinator, fn) {
-  return {
-    _tag: "transform",
-    _meta: combinator._meta,
-    _def: { tag: "transform", parser: combinator, fn },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return result;
-      return { ok: true, value: fn(result.value, result.span), span: result.span };
-    }
-  };
-}
-function trivia(combinator) {
-  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
-  return {
-    _tag: combinator._tag,
-    _meta: {
-      ...combinator._meta,
-      isTrivia: true,
-      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
-    },
-    _def: { tag: "trivia", parser: combinator },
-    parse: combinator.parse.bind(combinator)
-  };
-}
-function classifiedTrivia(arms) {
-  const entries = Object.entries(arms);
-  if (entries.length === 0) {
-    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
-  }
-  for (let i = 0; i < entries.length; i++) {
-    const [name, arm] = entries[i];
-    const first = arm._meta.firstSet;
-    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
-      throw new TypeError(
-        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
-      );
-    }
-  }
-  const labeledArms = entries.map(([name, arm]) => label(name, arm));
-  const result = trivia(oneOrMore(choice(...labeledArms)));
-  result._meta.rootTriviaClassified = true;
-  return result;
-}
-function label(name, combinator) {
-  return {
-    _tag: combinator._tag,
-    _meta: combinator._meta,
-    _def: { tag: "label", label: name, parser: combinator },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return { ok: false, expected: [name], span: result.span };
-      return result;
-    }
-  };
-}
-function field(name, combinator) {
-  return {
-    _tag: combinator._tag,
-    _meta: combinator._meta,
-    _def: { tag: "field", name, parser: combinator },
-    parse(input, pos, ctx) {
-      const result = combinator.parse(input, pos, ctx);
-      if (!result.ok) return result;
-      ctx._fields?.push({ name, value: result.value, span: result.span });
-      return result;
-    }
-  };
-}
-
-// src/regex/first-set.ts
-var ANY = { t: "any" };
-var EMPTY2 = { t: "empty" };
-function charNode(set, nl) {
-  return { t: "char", set, nl };
-}
-function rangesToSet(ranges) {
-  let fs = empty();
-  for (const [lo, hi] of ranges) fs = union(fs, fromRange(lo, hi));
-  return fs;
-}
-function rangesHaveNewline(ranges) {
-  return ranges.some(([lo, hi]) => lo <= 10 && 10 <= hi);
-}
-var BAIL = /* @__PURE__ */ Symbol("regex-bail");
-function parseRegex(src) {
-  let i = 0;
-  const parseAlt = () => {
-    const arms = [parseSeq()];
-    while (src[i] === "|") {
-      i++;
-      arms.push(parseSeq());
-    }
-    return arms.length === 1 ? arms[0] : { t: "alt", arms };
-  };
-  const parseSeq = () => {
-    const parts = [];
-    while (i < src.length) {
-      const ch2 = src[i];
-      if (ch2 === "|" || ch2 === ")") break;
-      parts.push(parseQuantified());
-    }
-    if (parts.length === 0) return EMPTY2;
-    return parts.length === 1 ? parts[0] : { t: "seq", parts };
-  };
-  const parseQuantified = () => {
-    const atom = parseAtom();
-    const ch2 = src[i];
-    let min = null;
-    if (ch2 === "*") {
-      min = 0;
-      i++;
-    } else if (ch2 === "+") {
-      min = 1;
-      i++;
-    } else if (ch2 === "?") {
-      min = 0;
-      i++;
-    } else if (ch2 === "{") {
-      min = parseBraceQuantifier();
-    }
-    if (min === null) return atom;
-    if (src[i] === "?") i++;
-    return { t: "rep", node: atom, min };
-  };
-  const parseBraceQuantifier = () => {
-    const close = src.indexOf("}", i);
-    if (close === -1) return null;
-    const m = /^(\d+)(?:,(\d*))?$/.exec(src.slice(i + 1, close));
-    if (!m) return null;
-    i = close + 1;
-    return Number.parseInt(m[1], 10);
-  };
-  const parseAtom = () => {
-    const ch2 = src[i];
-    switch (ch2) {
-      case "(":
-        return parseGroup();
-      case "[":
-        return parseClass();
-      case ".":
-        i++;
-        return charNode(any(), false);
-      // `.` matches any char except line terminators
-      case "\\":
-        return parseEscape();
-      case "^":
-      case "$":
-        i++;
-        return EMPTY2;
-      // anchors are zero-width
-      case "{":
-        i++;
-        return charNode(fromRange(123, 123), false);
-      // a `{` with nothing to quantify is a literal brace
-      default:
-        i += ch2.length;
-        return charNode(fromRange(ch2.codePointAt(0), ch2.codePointAt(0)), ch2 === "\n");
-    }
-  };
-  const parseGroup = () => {
-    i++;
-    let lookaround = false;
-    if (src[i] === "?") {
-      const c1 = src[i + 1];
-      if (c1 === ":") i += 2;
-      else if (c1 === "=" || c1 === "!") {
-        i += 2;
-        lookaround = true;
-      } else if (c1 === "<") {
-        const c2 = src[i + 2];
-        if (c2 === "=" || c2 === "!") {
-          i += 3;
-          lookaround = true;
-        } else {
-          const gt = src.indexOf(">", i);
-          if (gt === -1) throw BAIL;
-          i = gt + 1;
+            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
+          } else {
+            sepPos = advanceTrivia(input, cur, ctx);
+          }
         }
-      } else throw BAIL;
-    }
-    const inner = parseAlt();
-    if (src[i] !== ")") throw BAIL;
-    i++;
-    return lookaround ? EMPTY2 : inner;
-  };
-  const parseClass = () => {
-    let k = i + 1;
-    const negated = src[k] === "^";
-    if (negated) k++;
-    let body = "";
-    while (k < src.length && src[k] !== "]") {
-      if (src[k] === "\\") {
-        body += src[k] + (src[k + 1] ?? "");
-        k += 2;
-      } else {
-        body += src[k];
-        k++;
+        const sep = separator.parse(input, sepPos, ctx);
+        if (!sep.ok) {
+          rollbackTrivia(ctx, loopMark);
+          if (sep.committed) return sep;
+          break;
+        }
+        if (!keepSeparators) demoteCapturedToRaw(ctx, loopMark.leaves);
+        const sepMark = trailing === "forbid" ? void 0 : saveTriviaMark(ctx);
+        let nextPos = sep.span.end;
+        if (ctx.trivia) {
+          if (needsDeferredTriviaCommit(ctx)) {
+            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
+          } else {
+            nextPos = advanceTrivia(input, sep.span.end, ctx);
+          }
+        }
+        const next = combinator.parse(input, nextPos, ctx);
+        if (!next.ok) {
+          if (next.committed) return next;
+          const term = ctx._tolerant ? ctx._sync : void 0;
+          if (term !== void 0 && !matchesAt(term, input, nextPos, ctx)) {
+            expected ??= deriveExpected(combinator);
+            const rec = recoverScan(input, nextPos, ctx, orSentinel(separator, term), expected);
+            values.push(rec.error);
+            captureError(ctx, rec.error);
+            cur = rec.end;
+            continue;
+          }
+          if (sepMark !== void 0) {
+            rollbackTrivia(ctx, sepMark);
+            cur = sep.span.end;
+            break;
+          }
+          rollbackTrivia(ctx, loopMark);
+          break;
+        }
+        values.push(next.value);
+        cur = next.span.end;
       }
+      if (values.length < min) return failAt2(cur);
+      return { ok: true, value: values, span: { start: pos, end: cur } };
     }
-    if (src[k] !== "]") throw BAIL;
-    i = k + 1;
-    const ranges = parseClassRanges(body);
-    if (negated) return charNode(any(), !ranges || !rangesHaveNewline(ranges));
-    if (!ranges) return charNode(any(), true);
-    return charNode(rangesToSet(ranges), rangesHaveNewline(ranges));
   };
-  const parseEscape = () => {
-    const e = src[i + 1];
-    if (e === void 0) throw BAIL;
-    if (e === "u" && /^[0-9a-fA-F]{4}$/.test(src.slice(i + 2, i + 6))) {
-      const cp = Number.parseInt(src.slice(i + 2, i + 6), 16);
-      i += 6;
-      return charNode(fromRange(cp, cp), cp === 10);
-    }
-    if (e === "x" && /^[0-9a-fA-F]{2}$/.test(src.slice(i + 2, i + 4))) {
-      const cp = Number.parseInt(src.slice(i + 2, i + 4), 16);
-      i += 4;
-      return charNode(fromRange(cp, cp), cp === 10);
-    }
-    i += 2;
-    switch (e) {
-      case "d":
-        return charNode(rangesToSet(shorthandRanges("d")), false);
-      case "w":
-        return charNode(rangesToSet(shorthandRanges("w")), false);
-      case "s":
-        return charNode(rangesToSet(shorthandRanges("s")), true);
-      case "D":
-      case "W":
-      case "S":
-        return charNode(any(), true);
-      // negated shorthand → widen
-      case "b":
-      case "B":
-        return EMPTY2;
-      // word boundary: zero-width
-      case "n":
-        return charNode(fromRange(10, 10), true);
-      case "r":
-        return charNode(fromRange(13, 13), false);
-      case "t":
-        return charNode(fromRange(9, 9), false);
-      case "f":
-        return charNode(fromRange(12, 12), false);
-      case "v":
-        return charNode(fromRange(11, 11), false);
-      case "0":
-        return charNode(fromRange(0, 0), false);
-      default:
-        if (e >= "1" && e <= "9") return ANY;
-        return charNode(fromRange(e.codePointAt(0), e.codePointAt(0)), e === "\n");
+}
+
+// src/combinators/map.ts
+function transform(combinator, fn) {
+  return {
+    _tag: "transform",
+    _meta: combinator._meta,
+    _def: { tag: "transform", parser: combinator, fn },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      return { ok: true, value: fn(result.value, result.span), span: result.span };
     }
   };
-  const node2 = parseAlt();
-  if (i < src.length) throw BAIL;
-  return node2;
 }
-function nullable(n) {
-  switch (n.t) {
-    case "char":
-      return false;
-    case "any":
-      return true;
-    case "empty":
-      return true;
-    case "seq":
-      return n.parts.every(nullable);
-    case "alt":
-      return n.arms.some(nullable);
-    case "rep":
-      return n.min === 0 || nullable(n.node);
-  }
+function trivia(combinator) {
+  const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
+  return {
+    _tag: combinator._tag,
+    _meta: {
+      ...combinator._meta,
+      isTrivia: true,
+      ...kindLabels ? { triviaKindLabels: kindLabels } : {}
+    },
+    _def: { tag: "trivia", parser: combinator },
+    parse: combinator.parse.bind(combinator)
+  };
 }
-function firstSet(n) {
-  switch (n.t) {
-    case "char":
-      return n.set;
-    case "any":
-      return any();
-    case "empty":
-      return empty();
-    case "rep":
-      return firstSet(n.node);
-    case "alt": {
-      let fs = empty();
-      for (const arm of n.arms) fs = union(fs, firstSet(arm));
-      return fs;
-    }
-    case "seq": {
-      let fs = empty();
-      for (const part of n.parts) {
-        fs = union(fs, firstSet(part));
-        if (!nullable(part)) break;
-      }
-      return fs;
+function classifiedTrivia(arms) {
+  const entries = Object.entries(arms);
+  if (entries.length === 0) {
+    throw new TypeError("classifiedTrivia() requires at least one named trivia arm.");
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const [name, arm] = entries[i];
+    const first = arm._meta.firstSet;
+    if (matchesEmpty(arm) || first.kind !== "ranges" || first.ranges.length === 0) {
+      throw new TypeError(
+        `classifiedTrivia(): ${JSON.stringify(name)} must be non-nullable with a concrete finite first set.`
+      );
     }
   }
+  const labeledArms = entries.map(([name, arm]) => label(name, arm));
+  const result = trivia(oneOrMore(choice(...labeledArms)));
+  result._meta.rootTriviaClassified = true;
+  return result;
 }
-function canConsumeNewline(n) {
-  switch (n.t) {
-    case "char":
-      return n.nl;
-    case "any":
-      return true;
-    case "empty":
-      return false;
-    case "rep":
-      return canConsumeNewline(n.node);
-    case "alt":
-      return n.arms.some(canConsumeNewline);
-    case "seq":
-      return n.parts.some(canConsumeNewline);
-  }
+function label(name, combinator) {
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "label", label: name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return { ok: false, expected: [name], span: result.span };
+      return result;
+    }
+  };
 }
-function firstSetFromRegex(source) {
-  let ast;
-  try {
-    ast = parseRegex(source);
-  } catch {
-    return { firstSet: any(), canMatchNewline: true };
-  }
-  if (nullable(ast)) return { firstSet: any(), canMatchNewline: canConsumeNewline(ast) };
-  return { firstSet: firstSet(ast), canMatchNewline: canConsumeNewline(ast) };
+function field(name, combinator) {
+  return {
+    _tag: combinator._tag,
+    _meta: combinator._meta,
+    _def: { tag: "field", name, parser: combinator },
+    parse(input, pos, ctx) {
+      const result = combinator.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      ctx._fields?.push({ name, value: result.value, span: result.span });
+      return result;
+    }
+  };
 }
 
 // src/combinators/regex.ts
@@ -4983,8 +5306,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;
@@ -5159,7 +5500,6 @@ function directArrayProjection(fn, fnSrc, arity) {
 
 // src/table/encode.ts
 import {
-  assertLexicalCapabilityClosure,
   collectLexicalCapabilities,
   winnerWrapsReference as winnerWrapsReference2
 } from "../compiler/token-capability.js";
@@ -5541,6 +5881,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;
@@ -5947,9 +6306,75 @@ var Encoder = class {
    * nothing consults the resolver and nothing changes, which is why the runtime
    * leg's counts are byte-for-byte what they were.
    */
-  refResolver() {
-    const w = this.winners;
-    return w === void 0 ? void 0 : (name) => w[name];
+  refResolver() {
+    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) {
@@ -6236,9 +6661,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;
@@ -6247,6 +6702,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":
@@ -6276,8 +6735,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)) {
@@ -6436,6 +6898,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);
@@ -6604,6 +7067,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
     });
   }
 };
@@ -6648,7 +7115,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]);
@@ -7781,13 +8247,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();
@@ -7810,25 +8280,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;
 }
@@ -7895,6 +8366,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 {
@@ -7976,6 +8603,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)
@@ -8041,6 +8678,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);
 }
@@ -8053,11 +8724,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
@@ -8067,7 +8739,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
@@ -8082,14 +8754,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)
@@ -8147,37 +8821,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();
@@ -8204,9 +8952,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;
@@ -8294,7 +9150,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}`;
@@ -8545,20 +9402,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
@@ -8614,12 +9475,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
@@ -8642,9 +9504,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}
@@ -8656,9 +9518,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
@@ -8666,14 +9528,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
 }
@@ -8772,57 +9635,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
 }`;
         }
@@ -8841,30 +9840,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))
@@ -8872,33 +9849,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
 }
@@ -8934,23 +9921,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{
@@ -9057,7 +10046,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
 }`;
@@ -9079,7 +10068,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}
@@ -9089,6 +10093,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))
@@ -9127,6 +10132,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})`;
@@ -9140,7 +10146,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
@@ -9151,7 +10162,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
@@ -9185,7 +10199,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
 }`;
@@ -9203,7 +10217,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")}
@@ -9218,7 +10232,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]
@@ -9985,6 +11005,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();
@@ -10230,7 +11261,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;
@@ -10314,6 +11345,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;
   }
@@ -10584,7 +11640,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);
@@ -11327,6 +12384,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);
@@ -11381,7 +12439,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;
@@ -11466,7 +12524,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];
@@ -11555,7 +12613,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 });
@@ -11565,7 +12623,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];
@@ -11574,7 +12632,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;
@@ -11586,10 +12644,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 });
@@ -11599,10 +12657,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];
@@ -11611,9 +12669,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;
@@ -11621,43 +12679,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);
@@ -11828,6 +12886,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;
@@ -11857,7 +12922,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;
@@ -11920,7 +12988,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;
@@ -11936,7 +13004,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;
@@ -11953,7 +13021,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;
@@ -12526,20 +13594,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;
@@ -12554,13 +13616,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;
@@ -12651,6 +13709,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);
@@ -13061,7 +14147,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;
@@ -14594,7 +15680,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]));
@@ -15116,6 +16202,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": {