parseman 0.47.1 → 0.48.0

package/dist/analysis/diagnostics.js

@@ -1,4 +1,40 @@
 // src/combinators/first-set.ts
+function classifyFinalChoice(arms, resolve) {
+  const firstSets = [];
+  const nullable2 = [];
+  let exclusive = true;
+  for (const arm of arms) {
+    const empty2 = matchesEmpty(arm, /* @__PURE__ */ new Set(), resolve);
+    nullable2.push(empty2);
+    firstSets.push(empty2 ? { kind: "any" } : firstSetOf(arm, /* @__PURE__ */ new Set(), resolve));
+    if (empty2) exclusive = false;
+  }
+  if (exclusive) {
+    const ascii = new Uint8Array(128);
+    let highOwners = 0;
+    for (let arm = 0; arm < firstSets.length && exclusive; arm++) {
+      const first = firstSets[arm];
+      if (first.kind !== "ranges" || first.ranges.length === 0) {
+        exclusive = false;
+        break;
+      }
+      let ownsHigh = false;
+      for (const range of first.ranges) {
+        if (range.hi >= 128) ownsHigh = true;
+        for (let code = Math.max(0, range.lo); code <= Math.min(127, range.hi); code++) {
+          if (ascii[code] !== 0) {
+            exclusive = false;
+            break;
+          }
+          ascii[code] = 1;
+        }
+        if (!exclusive) break;
+      }
+      if (ownsHigh && ++highOwners > 1) exclusive = false;
+    }
+  }
+  return { exclusive, firstSets, nullable: nullable2 };
+}
 function resolveNamedRef(p, resolve) {
   if (resolve === void 0) return void 0;
   const name = p._ruleName;
@@ -516,16 +552,33 @@ function pushTriviaLogEntry(ctx, start, end, kindIndex) {
   }
 }
 
+// src/combinators/expected.ts
+function directTerminalFailureExpected(def) {
+  switch (def.tag) {
+    case "literal":
+      return [JSON.stringify(def.value)];
+    case "regex":
+      return [`/${def.source}/`];
+    case "keywords":
+      return ["keyword"];
+  }
+}
+function assertionFailureExpected(positive, childTag) {
+  return [`${positive ? "peek" : "not"}(${childTag})`];
+}
+
 // src/combinators/keywords.ts
 function escapeRe(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function keywordsRegExp(words, boundary, caseInsensitive) {
+  const alt = words.map(escapeRe).join("|");
+  const boundarySource = boundary ? `(?![${boundary}])` : "";
+  return new RegExp(`(?:${alt})${boundarySource}`, caseInsensitive ? "iy" : "uy");
+}
 function keywords(words, opts = {}) {
   const sorted = [...new Set(words)].sort((a, b) => b.length - a.length);
-  const alt = sorted.map(escapeRe).join("|");
-  const boundary = opts.boundary ? `(?![${opts.boundary}])` : "";
-  const flags = opts.caseInsensitive ? "iy" : "uy";
-  const re = new RegExp(`(?:${alt})${boundary}`, flags);
+  const re = keywordsRegExp(sorted, opts.boundary, opts.caseInsensitive ?? false);
   let firstSet2 = empty();
   for (const w of sorted) {
     if (w.length === 0) continue;
@@ -536,15 +589,21 @@ function keywords(words, opts = {}) {
     }
   }
   const meta = { firstSet: firstSet2, canMatchNewline: false, isTrivia: false };
+  const def = {
+    tag: "keywords",
+    words: sorted,
+    caseInsensitive: opts.caseInsensitive ?? false,
+    boundary: opts.boundary
+  };
   return {
     _tag: "keywords",
     _meta: meta,
-    _def: { tag: "keywords", words: sorted, caseInsensitive: opts.caseInsensitive ?? false, boundary: opts.boundary },
+    _def: def,
     parse(input, pos, ctx) {
       re.lastIndex = pos;
       const m = re.exec(input);
       if (m === null || m.index !== pos) {
-        return failAt(ctx, ["keyword"], pos);
+        return failAt(ctx, directTerminalFailureExpected(def), pos);
       }
       const value = m[0];
       const span = { start: pos, end: pos + value.length };
@@ -716,6 +775,179 @@ function createDetachedParseContext(trackLines, state) {
   return ctx;
 }
 
+// src/cst/trivia-css-scanner.ts
+var CSS_WS_SOURCE = "[ \\t\\n\\r\\f]+";
+var CSS_LINE_COMMENT_SOURCE = "\\/\\/[^\\n\\r]*";
+var CSS_BLOCK_COMMENT_SOURCE = "\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/";
+function scanWhitespace(input, cur) {
+  let pos = cur;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c !== 32 && c !== 9 && c !== 10 && c !== 13 && c !== 12) break;
+    pos++;
+  }
+  return pos;
+}
+function scanLineComment(input, cur) {
+  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 47) return cur;
+  let pos = cur + 2;
+  while (pos < input.length) {
+    const c = input.charCodeAt(pos);
+    if (c === 10 || c === 13) break;
+    pos++;
+  }
+  return pos;
+}
+function scanBlockComment(input, cur) {
+  if (input.charCodeAt(cur) !== 47 || input.charCodeAt(cur + 1) !== 42) return cur;
+  const close = input.indexOf("*/", cur + 2);
+  return close < 0 ? cur : close + 2;
+}
+function scanWsLineBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const ws = scanWhitespace(input, pos);
+    if (ws !== pos) {
+      pos = ws;
+      continue;
+    }
+    const line = scanLineComment(input, pos);
+    if (line !== pos) {
+      pos = line;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanWsBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const ws = scanWhitespace(input, pos);
+    if (ws !== pos) {
+      pos = ws;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanLineBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const line = scanLineComment(input, pos);
+    if (line !== pos) {
+      pos = line;
+      continue;
+    }
+    const block = scanBlockComment(input, pos);
+    if (block !== pos) {
+      pos = block;
+      continue;
+    }
+    return pos;
+  }
+}
+function scanBlockTrivia(input, cur) {
+  let pos = cur;
+  for (; ; ) {
+    const block = scanBlockComment(input, pos);
+    if (block === pos) return pos;
+    pos = block;
+  }
+}
+function visitWsLineBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanWhitespace(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanLineComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 2);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitWsBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanWhitespace(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitLineBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    let end = scanLineComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 0);
+      pos = end;
+      continue;
+    }
+    end = scanBlockComment(input, pos);
+    if (end !== pos) {
+      visit(pos, end, 1);
+      pos = end;
+      continue;
+    }
+    return pos;
+  }
+}
+function visitBlock(input, cur, visit) {
+  let pos = cur;
+  for (; ; ) {
+    const end = scanBlockComment(input, pos);
+    if (end === pos) return pos;
+    visit(pos, end, 0);
+    pos = end;
+  }
+}
+function commonCssTriviaScanner(sources) {
+  if (sources.length === 3 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_LINE_COMMENT_SOURCE && sources[2] === CSS_BLOCK_COMMENT_SOURCE) return scanWsLineBlockTrivia;
+  if (sources.length === 2 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return scanWsBlockTrivia;
+  if (sources.length === 2 && sources[0] === CSS_LINE_COMMENT_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return scanLineBlockTrivia;
+  if (sources.length === 1 && sources[0] === CSS_BLOCK_COMMENT_SOURCE) return scanBlockTrivia;
+  return null;
+}
+function commonCssTriviaVisitor(sources) {
+  if (sources.length === 3 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_LINE_COMMENT_SOURCE && sources[2] === CSS_BLOCK_COMMENT_SOURCE) return visitWsLineBlock;
+  if (sources.length === 2 && sources[0] === CSS_WS_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return visitWsBlock;
+  if (sources.length === 2 && sources[0] === CSS_LINE_COMMENT_SOURCE && sources[1] === CSS_BLOCK_COMMENT_SOURCE) return visitLineBlock;
+  if (sources.length === 1 && sources[0] === CSS_BLOCK_COMMENT_SOURCE) return visitBlock;
+  return null;
+}
+
 // src/cst/trivia-charscan.ts
 function inRanges(cp, ranges) {
   for (let i = 0; i < ranges.length; i++) {
@@ -869,6 +1101,35 @@ function classifyParser(p) {
   if (d.tag !== "regex" || d.flags) return null;
   return classifyArm(d.source);
 }
+function plainRegexSource(p) {
+  const d = p._def;
+  return d.tag === "regex" && d.flags === "" ? d.source : null;
+}
+var visitSpec0;
+var visitSpec1;
+var visitSpec2;
+var visitSpec3;
+var visitValue0;
+var visitValue1;
+var visitValue2;
+var visitValue3;
+function commonLabeledTriviaVisitor(spec) {
+  if (spec === visitSpec0) return visitValue0;
+  if (spec === visitSpec1) return visitValue1;
+  if (spec === visitSpec2) return visitValue2;
+  if (spec === visitSpec3) return visitValue3;
+  const sources = spec.minRepeats <= 1 ? spec.arms.map((arm) => plainRegexSource(arm.parser)) : [];
+  const visitor = commonCssTriviaVisitor(sources);
+  visitSpec3 = visitSpec2;
+  visitValue3 = visitValue2;
+  visitSpec2 = visitSpec1;
+  visitValue2 = visitValue1;
+  visitSpec1 = visitSpec0;
+  visitValue1 = visitValue0;
+  visitSpec0 = spec;
+  visitValue0 = visitor;
+  return visitor;
+}
 var armSpec0;
 var armSpec1;
 var armSpec2;
@@ -1067,6 +1328,8 @@ function scanLabeledTriviaEnd(input, cur, spec, state) {
 }
 function visitLabeledTrivia(input, cur, spec, state, visit) {
   if (spec.minRepeats > 1) return void 0;
+  const common = commonLabeledTriviaVisitor(spec);
+  if (common !== null) return common(input, cur, visit);
   const chars = charArmsFor(spec);
   if (chars !== null) return charTriviaVisit(input, cur, chars, visit);
   let pos = cur;
@@ -1166,6 +1429,14 @@ function triviaKindMask(labels, keep) {
 // src/combinators/trivia-skip.ts
 var NOOP_COMMIT = () => {
 };
+function triviaScanEnd(scan) {
+  return typeof scan === "number" ? scan : scan.end;
+}
+function commitTriviaScan(scan) {
+  if (typeof scan === "number") return scan;
+  scan.commit();
+  return scan.end;
+}
 var fastTrivia0;
 var fastTrivia1;
 var fastTrivia2;
@@ -1235,7 +1506,7 @@ function rollbackLookahead(ctx, mark) {
 function scanWithLabels(input, cur, ctx) {
   const triviaP = ctx.trivia;
   const spec = analyzeLabeledTrivia(triviaP);
-  if (!spec) return { end: cur, commit: NOOP_COMMIT };
+  if (!spec) return cur;
   const log = ctx._triviaLog;
   const rootLog = ctx._rootTriviaLog;
   const rootKinds = ctx._rootTriviaKindIndex;
@@ -1253,7 +1524,8 @@ function scanWithLabels(input, cur, ctx) {
     }
   });
   if (visitedEnd !== void 0) {
-    if (visitedEnd === cur) return { end: cur, commit: NOOP_COMMIT };
+    if (visitedEnd === cur) return cur;
+    if (fullRows === void 0 && rootRows === void 0 && cstRows === void 0) return visitedEnd;
     return {
       end: visitedEnd,
       commit: () => {
@@ -1272,7 +1544,7 @@ function scanWithLabels(input, cur, ctx) {
     };
   }
   const { end, chunks } = scanLabeledTriviaChunks(input, cur, spec, ctx.state);
-  if (end === cur) return { end: cur, commit: NOOP_COMMIT };
+  if (end === cur) return cur;
   return {
     end,
     commit: () => recordTriviaChunks(ctx, chunks)
@@ -1313,7 +1585,7 @@ function advanceTrivia(input, cur, ctx) {
   const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return tr.ok && tr.span.end > cur ? tr.span.end : cur;
 }
-function scanTrivia(input, cur, ctx) {
+function scanTriviaCompact(input, cur, ctx) {
   const triviaP = ctx.trivia;
   if (!triviaP) return { end: cur, commit: NOOP_COMMIT };
   const log = ctx._triviaLog;
@@ -1354,7 +1626,7 @@ function scanTrivia(input, cur, ctx) {
   }
   if (ctx.triviaKindLabels && (log !== void 0 || rootLog !== void 0 || captureTl)) {
     const scan = scanWithLabels(input, cur, ctx);
-    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, scan.end);
+    if (trackTriviaLines) recordLineRangeFromContext(ctx, input, cur, triviaScanEnd(scan));
     return scan;
   }
   if (ctx.triviaKindLabels) {
@@ -1384,6 +1656,10 @@ function scanTrivia(input, cur, ctx) {
   const tr = parseTriviaNoCapture(triviaP, input, cur, ctx);
   return { end: tr.ok ? tr.span.end : cur, commit: NOOP_COMMIT };
 }
+function scanTrivia(input, cur, ctx) {
+  const scan = scanTriviaCompact(input, cur, ctx);
+  return typeof scan === "number" ? { end: scan, commit: NOOP_COMMIT } : scan;
+}
 function skipTriviaScanned(s, input, cur, ctx) {
   const end = s(input, cur);
   if (end !== cur) {
@@ -1396,14 +1672,12 @@ function skipTriviaScanned(s, input, cur, ctx) {
 }
 function consumeTrivia(input, cur, ctx) {
   if (!needsDeferredTriviaCommit(ctx)) return advanceTrivia(input, cur, ctx);
-  const scan = scanTrivia(input, cur, ctx);
-  scan.commit();
-  return scan.end;
+  return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
 }
 function probeTriviaEnd(input, cur, ctx) {
   if (!ctx.trivia) return cur;
   const probeCtx = { ...ctx, trackLines: false };
-  if (needsDeferredTriviaCommit(probeCtx)) return scanTrivia(input, cur, probeCtx).end;
+  if (needsDeferredTriviaCommit(probeCtx)) return triviaScanEnd(scanTriviaCompact(input, cur, probeCtx));
   return advanceTrivia(input, cur, probeCtx);
 }
 function fastTriviaScanner(trivia2) {
@@ -1431,10 +1705,16 @@ function buildFastTriviaScanner(trivia2) {
   const one = regexTriviaScanner(repeat);
   if (one) return loopScanner([one]);
   if (repeat._def.tag !== "choice") return null;
+  const fused = commonCssTriviaScanner(repeat._def.parsers.map(triviaRegexSource));
+  if (fused !== null) return fused;
   const arms = repeat._def.parsers.map(regexTriviaScanner);
   if (arms.some((s) => s === null)) return null;
   return loopScanner(arms);
 }
+function triviaRegexSource(parser2) {
+  const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
+  return d.tag === "regex" && d.flags === "" ? d.source : null;
+}
 function loopScanner(arms) {
   return (input, cur) => {
     let pos = cur;
@@ -1734,7 +2014,11 @@ function peek(combinator) {
       const result = combinator.parse(input, pos, ctx);
       rollbackLookahead(ctx, mark);
       if (result.ok) return { ok: true, value: null, span: { start: pos, end: pos } };
-      return { ok: false, expected: [`peek(${combinator._tag})`], span: { start: pos, end: pos } };
+      return {
+        ok: false,
+        expected: assertionFailureExpected(true, combinator._tag),
+        span: { start: pos, end: pos }
+      };
     }
   };
 }
@@ -1878,11 +2162,12 @@ function parser(opts, root) {
   const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
   const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
   const forceCaptureTrivia = opts.captureTrivia === true;
-  const trackLinesOf = opts.trackLines === true ? TRACK_LINES_ON : opts.trackLines === false ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
+  const trackLinesPolicy = opts.trackLines === true ? "on" : opts.trackLines === false ? "off" : "inherit";
+  const trackLinesOf = trackLinesPolicy === "on" ? TRACK_LINES_ON : trackLinesPolicy === "off" ? TRACK_LINES_OFF : TRACK_LINES_INHERIT;
   const captureKinds = clearTrivia ? void 0 : opts.captureTriviaKinds;
   const ownCaptureMask = captureKinds === void 0 ? void 0 : scopeLabels !== void 0 ? triviaKindMask(scopeLabels, captureKinds) : void 0;
   const inheritCaptureMask = captureKinds !== void 0 && scopeLabels === void 0;
-  return {
+  const grammar = {
     _tag: "grammar",
     _meta: {
       ...root._meta,
@@ -1901,7 +2186,9 @@ function parser(opts, root) {
       clearTrivia,
       ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
       ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
     },
     parse(input, pos, _ctx) {
       if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
@@ -1930,6 +2217,7 @@ function parser(opts, root) {
       return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
     }
   };
+  return grammar;
 }
 var _analyzed = /* @__PURE__ */ new WeakSet();
 function parse(combinator, input, opts = {}) {
@@ -3064,6 +3352,12 @@ function confirmedArityForDef(def) {
   });
   return null;
 }
+function buildReadsRaw(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 4;
+}
 function buildReadsTrivia(def) {
   if (!def.build) return true;
   const arity = confirmedArityForDef(def);
@@ -3245,6 +3539,8 @@ var OP_ATTEMPT = 38;
 var OP_LABEL = 39;
 var OP_COV = 40;
 var OP_SCOPE_PLAIN = 41;
+var OP_LEX_BODY = 42;
+var OP_LEX_PROGRAM = 43;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -3288,7 +3584,9 @@ var OP_NAMES = {
   [OP_ATTEMPT]: "ATTEMPT",
   [OP_LABEL]: "LABEL",
   [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN"
+  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
+  [OP_LEX_BODY]: "LEX_BODY",
+  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
 };
 
 // src/combinators/adjacency.ts
@@ -3509,15 +3807,372 @@ function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
   }
 }
 
+// src/table/lex-program.ts
+var LEX_NODE_TERMINAL = 0;
+var LEX_NODE_SEQUENCE2 = 1;
+var LEX_NODE_SEQUENCE3 = 2;
+var LEX_NODE_SEQUENCE4 = 3;
+var LEX_NODE_SEQUENCE5 = 4;
+var LEX_NODE_CHOICE2 = 5;
+var LEX_NODE_CHOICE4 = 6;
+var LEX_NODE_CHOICE8 = 7;
+var LEX_NODE_NOT = 8;
+var LEX_NODE_OPTIONAL = 9;
+function lexProgramDigest(words) {
+  let hash = 2166136261;
+  for (const word of words) {
+    hash ^= word | 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash | 0;
+}
+function classHas(cls, code) {
+  if (code < 0) return false;
+  if (code < 128) return cls.ascii[code] === 1;
+  for (let i = 0; i < cls.hi.length; i += 2) {
+    if (code >= cls.hi[i] && code <= cls.hi[i + 1]) return true;
+  }
+  return false;
+}
+var committed = (ctx) => ctx._fc === true;
+function trackLexLines(ctx, input, end) {
+  let at = ctx._lineScannedTo ?? 0;
+  const starts = ctx._lineStarts;
+  if (starts === void 0 || end <= at) return;
+  while (at < end) {
+    if (input.charCodeAt(at) === 10) starts.push(at + 1);
+    at++;
+  }
+  ctx._lineScannedTo = end;
+}
+function terminalNode(matcher, failure, tracksLines) {
+  const match = (input, pos) => {
+    const result = matcher(input, pos);
+    return result < 0 ? -1 : result / 2;
+  };
+  return {
+    match,
+    run: (input, pos, ctx) => {
+      const end = match(input, pos);
+      if (end < 0) {
+        ctx._fe = pos;
+        ctx._fx = failure;
+        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+        return -1;
+      }
+      if (tracksLines) trackLexLines(ctx, input, end);
+      return end;
+    }
+  };
+}
+function sequence2(a, b) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      return e0 < 0 ? -1 : b.match(input, e0);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      return b.run(input, e0, ctx);
+    }
+  };
+}
+function sequence3(a, b, c) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = b.match(input, e0);
+      return e1 < 0 ? -1 : c.match(input, e1);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = b.run(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      return c.run(input, e1, ctx);
+    }
+  };
+}
+function sequence4(a, b, c, d) {
+  const abc = sequence3(a, b, c);
+  return {
+    match: (input, pos) => {
+      const end = abc.match(input, pos);
+      return end < 0 ? -1 : d.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abc.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return d.run(input, end, ctx);
+    }
+  };
+}
+function sequence5(a, b, c, d, e) {
+  const abcd = sequence4(a, b, c, d);
+  return {
+    match: (input, pos) => {
+      const end = abcd.match(input, pos);
+      return end < 0 ? -1 : e.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abcd.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return e.run(input, end, ctx);
+    }
+  };
+}
+function appendExpected(acc, values) {
+  if (values === void 0 || values.length === 0) return acc;
+  if (acc === void 0) return values.slice();
+  acc.push(...values);
+  return acc;
+}
+function choiceNode(arms, classes, armExpected, choiceExpected) {
+  let matchTail = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], next = matchTail;
+    matchTail = (input, pos) => {
+      const end = arm.match(input, pos);
+      return end < 0 ? next(input, pos) : end;
+    };
+  }
+  let tail = (_input, pos, ctx, _lead, acc) => {
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceExpected;
+    return -1;
+  };
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    tail = (input, pos, ctx, lead2, acc) => {
+      if (cls !== void 0 && !classHas(cls, lead2)) {
+        return next(input, pos, ctx, lead2, appendExpected(acc, staticExpected));
+      }
+      ctx._fc = false;
+      const end = arm.run(input, pos, ctx);
+      if (end >= 0) return end;
+      const nextAcc = appendExpected(acc, ctx._fx);
+      if (committed(ctx)) {
+        if (nextAcc !== void 0) ctx._fx = nextAcc;
+        return -1;
+      }
+      return next(input, pos, ctx, lead2, nextAcc);
+    };
+  }
+  return {
+    match: matchTail,
+    run: (input, pos, ctx) => tail(input, pos, ctx, pos < input.length ? input.codePointAt(pos) : -1, void 0)
+  };
+}
+function notNode(body, failure) {
+  return {
+    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    run: (input, pos, ctx) => {
+      if (body.match(input, pos) < 0) return pos;
+      ctx._fe = pos;
+      ctx._fx = failure;
+      return -1;
+    }
+  };
+}
+function optionalNode(body) {
+  return {
+    match: (input, pos) => {
+      const end = body.match(input, pos);
+      return end < 0 ? pos : end;
+    },
+    run: (input, pos, ctx) => {
+      ctx._fc = false;
+      const end = body.run(input, pos, ctx);
+      return end < 0 && !committed(ctx) ? pos : end;
+    }
+  };
+}
+function fixedTreeRunner(words, matchers, classes, expected) {
+  const stack = [];
+  const pop = () => {
+    const value = stack.pop();
+    if (value === void 0) throw new TypeError("table lexical tree has an incomplete fixed body");
+    return value;
+  };
+  for (let at = 0; at < words.length; ) {
+    const op = words[at++];
+    if (op === LEX_NODE_TERMINAL) {
+      const matcher = matchers[words[at++]], failure = expected[words[at++]];
+      const tracks = words[at++];
+      if (matcher === void 0 || failure === void 0 || tracks !== 0 && tracks !== 1) {
+        throw new TypeError("table lexical tree terminal references an invalid pool entry");
+      }
+      stack.push(terminalNode(matcher, failure, tracks === 1));
+      continue;
+    }
+    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
+      const count = op - LEX_NODE_SEQUENCE2 + 2;
+      const nodes = Array.from({ length: count }, pop).reverse();
+      if (count === 2) stack.push(sequence2(nodes[0], nodes[1]));
+      else if (count === 3) stack.push(sequence3(nodes[0], nodes[1], nodes[2]));
+      else if (count === 4) stack.push(sequence4(nodes[0], nodes[1], nodes[2], nodes[3]));
+      else stack.push(sequence5(nodes[0], nodes[1], nodes[2], nodes[3], nodes[4]));
+      continue;
+    }
+    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
+      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
+      const choiceFx = expected[words[at++]];
+      if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
+      const armClasses = [];
+      const armFx = [];
+      for (let i = 0; i < count; i++) {
+        const cls = words[at++], fx = expected[words[at++]];
+        if (cls < -1 || cls >= 0 && classes[cls] === void 0 || fx === void 0) {
+          throw new TypeError("table lexical tree choice references an invalid pool entry");
+        }
+        armClasses.push(cls < 0 ? void 0 : classes[cls]);
+        armFx.push(fx);
+      }
+      const arms = Array.from({ length: count }, pop).reverse();
+      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      continue;
+    }
+    if (op === LEX_NODE_NOT) {
+      const failure = expected[words[at++]];
+      if (failure === void 0) throw new TypeError("table lexical tree assertion has an invalid expected set");
+      stack.push(notNode(pop(), failure));
+      continue;
+    }
+    if (op === LEX_NODE_OPTIONAL) {
+      stack.push(optionalNode(pop()));
+      continue;
+    }
+    throw new TypeError("table lexical tree has an unknown fixed body");
+  }
+  if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
+  return stack[0].run;
+}
+function buildLexProgramRunner(spec, matchers, classes, expected) {
+  if (spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3 || spec[0] === 0 && spec.length !== 13 || spec[0] === 1 && spec.length !== 12 || spec[0] === 2 && spec.length < 6 || spec[0] === 3 && spec.length !== 3) {
+    throw new TypeError("table lexical program has an invalid fixed body width");
+  }
+  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
+    throw new TypeError("table lexical program semantic digest is inconsistent");
+  }
+  if (spec[0] === 3) {
+    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
+      throw new TypeError("table balanced lexical program has an invalid scan reference");
+    }
+    const run = (_input, _pos, ctx, scan) => {
+      if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
+      const result = scan.parse(_input, _pos, ctx);
+      if (!result.ok) {
+        ctx._fe = result.span.start;
+        ctx._fx = result.expected ?? [];
+        return -1;
+      }
+      return result.span.end;
+    };
+    return Object.assign(run, { scan: spec[2] });
+  }
+  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
+  if (spec[0] === 1) {
+    const g00 = matchers[spec[2]], g01 = matchers[spec[3]];
+    const g02 = matchers[spec[4]], g03 = matchers[spec[5]];
+    const guard0Fx = expected[spec[6]];
+    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]];
+    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]];
+    const tracks2 = spec[11];
+    if (g00 === void 0 || g01 === void 0 || g02 === void 0 || g03 === void 0 || guard0Fx === void 0 || g1 === void 0 || guard1Fx === void 0 || terminal === void 0 || terminalFx === void 0 || tracks2 !== 0 && tracks2 !== 1) {
+      throw new TypeError("table lexical program references an invalid pool entry");
+    }
+    return (input, pos, ctx) => {
+      ctx._fc = false;
+      if (g00(input, pos) >= 0 || g01(input, pos) >= 0 || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = guard0Fx;
+        return -1;
+      }
+      ctx._fc = false;
+      if (g1(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = guard1Fx;
+        return -1;
+      }
+      ctx._fc = false;
+      const result = terminal(input, pos);
+      if (result < 0) {
+        ctx._fe = pos;
+        ctx._fx = terminalFx;
+        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+        return -1;
+      }
+      const end = result / 2;
+      if (tracks2 === 1) trackLexLines(ctx, input, end);
+      return end;
+    };
+  }
+  const cls = classes[spec[2]];
+  const choiceFx = expected[spec[3]];
+  const m0 = matchers[spec[4]], x0 = expected[spec[5]];
+  const m1 = matchers[spec[6]], x1 = expected[spec[7]];
+  const m2 = matchers[spec[8]], x2 = expected[spec[9]];
+  const m3 = matchers[spec[10]], x3 = expected[spec[11]];
+  const tracks = spec[12];
+  if (cls === void 0 || choiceFx === void 0 || m0 === void 0 || x0 === void 0 || m1 === void 0 || x1 === void 0 || m2 === void 0 || x2 === void 0 || m3 === void 0 || x3 === void 0 || tracks !== 0 && tracks !== 1) {
+    throw new TypeError("table lexical program references an invalid pool entry");
+  }
+  return (input, pos, ctx) => {
+    const lead2 = pos < input.length ? input.codePointAt(pos) : -1;
+    if (!classHas(cls, lead2)) {
+      ctx._fe = pos;
+      ctx._fx = choiceFx.slice();
+      return -1;
+    }
+    let acc;
+    const failed = (fx) => {
+      ctx._fe = pos;
+      ctx._fx = fx;
+      if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+      if (acc === void 0) acc = fx.slice();
+      else acc.push(...fx);
+    };
+    ctx._fc = false;
+    const success = (result2) => {
+      const end = result2 / 2;
+      if (tracks === 1) trackLexLines(ctx, input, end);
+      return end;
+    };
+    let result = m0(input, pos);
+    if (result >= 0) return success(result);
+    failed(x0);
+    ctx._fc = false;
+    result = m1(input, pos);
+    if (result >= 0) return success(result);
+    failed(x1);
+    ctx._fc = false;
+    result = m2(input, pos);
+    if (result >= 0) return success(result);
+    failed(x2);
+    ctx._fc = false;
+    result = m3(input, pos);
+    if (result >= 0) return success(result);
+    failed(x3);
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceFx;
+    return -1;
+  };
+}
+
 // src/combinators/repeat.ts
 function repItem(combinator, input, cur, ctx, guardable, mandatory) {
   const mark = saveTriviaMark(ctx);
   let pos = cur;
   if (ctx.trivia) {
     if (needsDeferredTriviaCommit(ctx)) {
-      const scan = scanTrivia(input, cur, ctx);
-      scan.commit();
-      pos = scan.end;
+      pos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
     } else {
       pos = advanceTrivia(input, cur, ctx);
     }
@@ -3737,9 +4392,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
         let sepPos = cur;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            sepPos = scan.end;
+            sepPos = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             sepPos = advanceTrivia(input, cur, ctx);
           }
@@ -3755,9 +4408,7 @@ function sepBy(combinator, separatorArg, opts = {}) {
         let nextPos = sep.span.end;
         if (ctx.trivia) {
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, sep.span.end, ctx);
-            scan.commit();
-            nextPos = scan.end;
+            nextPos = commitTriviaScan(scanTriviaCompact(input, sep.span.end, ctx));
           } else {
             nextPos = advanceTrivia(input, sep.span.end, ctx);
           }
@@ -4189,14 +4840,15 @@ function regex(pattern, flags = "") {
   const firstSet2 = !resolvedFlags.includes("i") ? raw.firstSet : resolvedFlags.includes("u") || resolvedFlags.includes("v") ? any() : asciiCaseFold(raw.firstSet);
   const canMatchNewline = raw.canMatchNewline;
   const meta = { firstSet: firstSet2, canMatchNewline, isTrivia: false };
+  const def = { tag: "regex", source, flags: resolvedFlags };
   return {
     _tag: "regex",
     _meta: meta,
-    _def: { tag: "regex", source, flags: resolvedFlags },
+    _def: def,
     parse(input, pos, ctx) {
       const scanEnd = scan?.(input, pos);
       if (scanEnd !== void 0) {
-        if (scanEnd === null) return failAt(ctx, [`/${source}/`], pos);
+        if (scanEnd === null) return failAt(ctx, directTerminalFailureExpected(def), pos);
         const value = input.slice(pos, scanEnd);
         const span2 = { start: pos, end: scanEnd };
         if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, scanEnd);
@@ -4206,7 +4858,7 @@ function regex(pattern, flags = "") {
       anchored.lastIndex = pos;
       const m = anchored.exec(input);
       if (m === null) {
-        return failAt(ctx, [`/${source}/`], pos);
+        return failAt(ctx, directTerminalFailureExpected(def), pos);
       }
       const span = { start: pos, end: pos + m[0].length };
       if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, span.end);
@@ -4216,6 +4868,26 @@ function regex(pattern, flags = "") {
   };
 }
 
+// src/table/lex-body.ts
+function buildLexBodyRecognizer(spec, constants) {
+  const raw = constants[spec[0]];
+  if (!(raw instanceof RegExp)) {
+    throw new TypeError("table lexical body does not reference a RegExp constant");
+  }
+  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
+    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
+  }
+  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, "")}y`);
+  const suffix = spec[1];
+  return (input, pos) => {
+    re.lastIndex = pos;
+    if (!re.test(input)) return -1;
+    const end = re.lastIndex;
+    if (suffix < 0) return end * 2;
+    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2;
+  };
+}
+
 // src/table/program.ts
 function closureArtifact(prog) {
   return { ...prog, asm: [] };
@@ -4259,6 +4931,8 @@ function expandCompact(p) {
     fns: p.f,
     lines: p.l ?? 0,
     dsp: p.p ?? [],
+    ...p.lx === void 0 ? {} : { lex: p.lx },
+    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
     ...p.lb === void 0 ? {} : { labels: p.lb },
     ...p.rc === void 0 ? {} : { classified: p.rc },
     ...p.h === void 0 ? {} : { hostMode: p.h },
@@ -4350,7 +5024,7 @@ function resolveClass(spec) {
   }
   return { ascii, hi };
 }
-function classHas(cls, code) {
+function classHas2(cls, code) {
   if (code < 0) return false;
   if (code < 128) return cls.ascii[code] === 1;
   const hi = cls.hi;
@@ -4403,6 +5077,7 @@ function resolveTable(prog) {
   if (hit !== void 0) return hit;
   const cc = prog.cc.map(resolveClass);
   const triviaBuilt = (prog.triviaSpecs ?? []).map(buildTrivia);
+  const lex = (prog.lex ?? []).map((spec) => buildLexBodyRecognizer(spec, prog.k));
   const built = {
     prog,
     code: Int32Array.from(prog.code),
@@ -4421,33 +5096,387 @@ function resolveTable(prog) {
       routed: d.routed,
       expected: d.expected
     })),
+    lex,
+    lexPrograms: (prog.lexPrograms ?? []).map((spec) => buildLexProgramRunner(spec, lex, cc, prog.fx)),
     rules: prog.rules
   };
   if (owner !== void 0) owner.resolved = built;
   return built;
 }
 
+// src/compiler/direct-projection.ts
+function directArrayProjection(fn, fnSrc, arity) {
+  let source = fnSrc;
+  if (source === void 0) {
+    source = Function.prototype.toString.call(fn);
+    if (source.includes("[native code]")) return null;
+  }
+  const match = /^\s*\(\s*\[([^\]]*)\]\s*\)\s*=>\s*([A-Za-z_$][\w$]*)\s*$/.exec(source);
+  if (match === null) return null;
+  const slots = match[1].split(",").map((slot) => slot.trim());
+  if (slots.length > arity) return null;
+  const result = match[2];
+  let selected = -1;
+  for (let i = 0; i < slots.length; i++) {
+    const slot = slots[i];
+    if (slot === "") continue;
+    if (!/^[A-Za-z_$][\w$]*$/.test(slot)) return null;
+    if (slot === result) {
+      if (selected >= 0) return null;
+      selected = i;
+    }
+  }
+  return selected >= 0 ? selected : null;
+}
+
 // src/table/encode.ts
-function emittableConst(v) {
-  const scalar = (x) => x === null || typeof x === "string" || typeof x === "number" || typeof x === "boolean";
-  if (scalar(v) || v instanceof RegExp) return true;
-  if (Array.isArray(v)) return v.every(scalar);
-  if (typeof v === "object" && v !== null) {
-    const proto = Object.getPrototypeOf(v);
-    if (proto !== Object.prototype && proto !== null) return false;
-    return Object.values(v).every((x) => scalar(x) || Array.isArray(x) && x.every(scalar));
-  }
-  return false;
+import {
+  assertLexicalCapabilityClosure,
+  collectLexicalCapabilities,
+  winnerWrapsReference as winnerWrapsReference2
+} from "../compiler/token-capability.js";
+
+// src/compiler/token-alphabet.ts
+function optionalSuffixLexBody(ir) {
+  if (ir.kind !== "sequence" || ir.parts.length !== 2) return void 0;
+  const [base, suffix] = ir.parts;
+  if (base?.kind !== "regex" || suffix?.kind !== "repeat" || suffix.min !== 0 || suffix.max !== 1 || !suffix.greedy || suffix.mode !== "possessive" || suffix.body.kind !== "literal" || suffix.body.caseInsensitive || suffix.body.value.length !== 1) return void 0;
+  return {
+    kind: "regex-optional-code-unit",
+    source: base.source,
+    flags: base.flags,
+    suffix: suffix.body.value
+  };
 }
-function wrapsRef(winner, p) {
-  let cur = winner;
-  for (let n = 0; n < 16; n++) {
-    if (cur === p) return true;
-    const d = cur._def;
-    if (d.tag !== "grammar" && d.tag !== "trivia") return false;
-    cur = d.parser;
-  }
-  return false;
+function selectOptionalSuffixLexBody(ir) {
+  const body = optionalSuffixLexBody(ir);
+  const character = { strategy: "character", estimatedOps: 5 };
+  if (body === void 0) return character;
+  const token2 = { strategy: "token", estimatedOps: 2, body };
+  return token2.estimatedOps < character.estimatedOps ? token2 : character;
+}
+function directTokenBodyParser(parser2, resolve) {
+  const outer = parser2._def;
+  if (outer.tag !== "token") return void 0;
+  let body = outer.parser;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(body)) {
+    seen.add(body);
+    const wrapper = body._def;
+    if (wrapper.tag === "grammar") {
+      if (wrapper.clearTrivia !== true || wrapper.triviaParser !== void 0 || wrapper.captureTrivia === true || wrapper.rootCapture === "opaque" || wrapper.constructionTrackLines !== "inherit" || wrapper.constructionCaptureTriviaKinds !== void 0) return void 0;
+      body = wrapper.parser;
+      continue;
+    }
+    if (wrapper.tag === "lazy") {
+      const target = resolvedLazyTarget(body, resolve);
+      if (target === void 0) return void 0;
+      body = target;
+      continue;
+    }
+    return body;
+  }
+  return void 0;
+}
+function directOptionalSuffixTokenBody(parser2, resolve) {
+  const inner = directTokenBodyParser(parser2, resolve);
+  if (inner === void 0) return void 0;
+  const sequence6 = inner._def;
+  if (sequence6.tag !== "sequence" || sequence6.parsers.length !== 2) return void 0;
+  let baseParser = sequence6.parsers[0];
+  const seenBase = /* @__PURE__ */ new Set();
+  while (baseParser !== void 0 && baseParser._def.tag === "lazy" && !seenBase.has(baseParser)) {
+    seenBase.add(baseParser);
+    baseParser = resolvedLazyTarget(baseParser, resolve);
+  }
+  const base = baseParser?._def;
+  const optional2 = sequence6.parsers[1]?._def;
+  if (base?.tag !== "regex" || optional2?.tag !== "optional") return void 0;
+  const suffix = optional2.parser._def;
+  if (suffix.tag !== "literal" || suffix.caseInsensitive || suffix.value.length !== 1) return void 0;
+  const selected = selectOptionalSuffixLexBody({
+    kind: "sequence",
+    parts: [
+      { kind: "regex", source: base.source, flags: base.flags },
+      {
+        kind: "repeat",
+        body: { kind: "literal", value: suffix.value, caseInsensitive: false },
+        min: 0,
+        max: 1,
+        greedy: true,
+        mode: "possessive"
+      }
+    ]
+  });
+  return selected.strategy === "token" ? {
+    ...selected.body,
+    baseCanMatchNewline: baseParser._meta.canMatchNewline,
+    suffixCanMatchNewline: optional2.parser._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(base)
+  } : void 0;
+}
+function directTerminalTokenBody(parser2, resolve) {
+  const outer = parser2._def;
+  if (outer.tag !== "token") return void 0;
+  const body = directTokenBodyParser(parser2, resolve);
+  if (body === void 0) return void 0;
+  const def = body._def;
+  if (def.tag === "regex") return {
+    kind: "regex-terminal",
+    source: def.source,
+    flags: def.flags,
+    canMatchNewline: body._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+  if (def.tag !== "keywords") return void 0;
+  const re = keywordsRegExp(def.words, def.boundary, def.caseInsensitive);
+  return {
+    kind: "regex-terminal",
+    source: re.source,
+    flags: re.flags,
+    canMatchNewline: body._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+}
+function directTerminalParser(parser2, resolve) {
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(parser2)) {
+    seen.add(parser2);
+    const def = parser2._def;
+    if (def.tag === "lazy") {
+      const target = resolvedLazyTarget(parser2, resolve);
+      if (target === void 0) return void 0;
+      parser2 = target;
+      continue;
+    }
+    if (def.tag === "token") {
+      parser2 = def.parser;
+      continue;
+    }
+    if (def.tag === "grammar") return void 0;
+    return parser2;
+  }
+  return void 0;
+}
+function directTerminalLexBody(parser2, resolve) {
+  const terminal = directTerminalParser(parser2, resolve);
+  if (terminal === void 0) return void 0;
+  const def = terminal._def;
+  if (def.tag === "literal") {
+    if (def.caseInsensitive) return void 0;
+    const source = def.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return {
+      kind: "regex-terminal",
+      source,
+      flags: "",
+      canMatchNewline: terminal._meta.canMatchNewline,
+      expected: directTerminalFailureExpected(def)
+    };
+  }
+  if (def.tag === "regex") return {
+    kind: "regex-terminal",
+    source: def.source,
+    flags: def.flags,
+    canMatchNewline: terminal._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+  if (def.tag !== "keywords") return void 0;
+  const re = keywordsRegExp(def.words, def.boundary, def.caseInsensitive);
+  return {
+    kind: "regex-terminal",
+    source: re.source,
+    flags: re.flags,
+    canMatchNewline: terminal._meta.canMatchNewline,
+    expected: directTerminalFailureExpected(def)
+  };
+}
+function directOrdered4TokenBody(parser2, resolve) {
+  const body = directTokenBodyParser(parser2, resolve);
+  return body === void 0 ? void 0 : directOrdered4Body(body, resolve);
+}
+function directOrdered4Body(body, resolve) {
+  if (body === void 0) return void 0;
+  const choice2 = body._def;
+  if (choice2.tag !== "choice" || choice2.parsers.length !== 4 || choice2.strategy.tag !== "firstMatch" || choice2.gates.some((gate) => gate !== null) || choice2.autoNot.some((check) => check !== null)) return void 0;
+  const arms = [];
+  let common;
+  for (const arm of choice2.parsers) {
+    const selected = directTerminalLexBody(arm, resolve);
+    if (selected === void 0) return void 0;
+    if (selected.canMatchNewline) return void 0;
+    const terminal = directTerminalParser(arm, resolve);
+    const first = firstSetOf(terminal, /* @__PURE__ */ new Set(), resolve);
+    if (first.kind !== "ranges" || first.ranges.length === 0) return void 0;
+    if (common === void 0) common = first;
+    else if (JSON.stringify(common) !== JSON.stringify(first)) return void 0;
+    arms.push(selected);
+  }
+  return {
+    kind: "ordered4-terminals",
+    commonFirstSet: common,
+    commonMissExpected: deriveExpected(body),
+    expected: arms.flatMap((arm) => arm.expected),
+    arms
+  };
+}
+function directNot2TokenBody(parser2, resolve) {
+  const body = directTokenBodyParser(parser2, resolve);
+  const sequence6 = body?._def;
+  if (sequence6?.tag !== "sequence" || sequence6.parsers.length !== 3) return void 0;
+  const [guard0Parser, guard1Parser, terminalParser] = sequence6.parsers;
+  const guard0Def = guard0Parser?._def;
+  const guard1Def = guard1Parser?._def;
+  if (guard0Def?.tag !== "not" || guard1Def?.tag !== "not") return void 0;
+  const ordered = directTokenBodyParser(guard0Def.parser, resolve) ?? directTerminalParser(guard0Def.parser, resolve);
+  const guard0Body = ordered === void 0 ? void 0 : directOrdered4Body(ordered, resolve);
+  const guard1 = directTerminalLexBody(guard1Def.parser, resolve);
+  const terminal = terminalParser === void 0 ? void 0 : directTerminalLexBody(terminalParser, resolve);
+  if (guard0Body === void 0 || guard1 === void 0 || terminal === void 0 || guard1.canMatchNewline || terminal.canMatchNewline) return void 0;
+  return {
+    kind: "not2-ordered4-terminal",
+    guard0Expected: assertionFailureExpected(false, guard0Def.parser._tag),
+    guard1Expected: assertionFailureExpected(false, guard1Def.parser._tag),
+    terminalExpected: terminal.expected,
+    guard0: guard0Body.arms,
+    guard1,
+    terminal
+  };
+}
+function directFixedLexNode(parser2, resolve, active, pureOnly = false) {
+  let current = parser2;
+  const wrappers = /* @__PURE__ */ new Set();
+  while (!wrappers.has(current)) {
+    wrappers.add(current);
+    const def = current._def;
+    if (def.tag === "lazy") {
+      const target = resolvedLazyTarget(current, resolve);
+      if (target === void 0) return void 0;
+      current = target;
+      continue;
+    }
+    if (def.tag === "token") {
+      current = def.parser;
+      continue;
+    }
+    break;
+  }
+  if (wrappers.has(current) && current !== parser2 && current._def.tag === "lazy") return void 0;
+  if (active.has(current)) return void 0;
+  active.add(current);
+  try {
+    const terminal = directTerminalLexBody(current, resolve);
+    if (terminal !== void 0) return { kind: "terminal", terminal };
+    const def = current._def;
+    if (def.tag === "grammar") {
+      if (!pureOnly || def.parser._def.tag !== "token" && (def.clearTrivia !== true || def.triviaParser !== void 0 || def.captureTrivia === true || def.rootCapture === "opaque")) return void 0;
+      return directFixedLexNode(def.parser, resolve, active, true);
+    }
+    if (def.tag === "sequence") {
+      if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve, active, pureOnly));
+      if (parts.some((part) => part === void 0)) return void 0;
+      return { kind: "sequence", parts };
+    }
+    if (def.tag === "choice") {
+      if (def.parsers.length !== 2 && def.parsers.length !== 4 && def.parsers.length !== 8 || def.strategy.tag !== "firstMatch" || def.gates.some((gate) => gate !== null) || def.autoNot.some((check) => check !== null)) return void 0;
+      const arms = def.parsers.map((arm) => directFixedLexNode(arm, resolve, active, pureOnly));
+      if (arms.some((arm) => arm === void 0)) return void 0;
+      const final = classifyFinalChoice(def.parsers, resolve);
+      return {
+        kind: "choice",
+        arms,
+        firstSets: final.firstSets,
+        armExpected: def.parsers.map(deriveExpected),
+        expected: def.parsers.flatMap(deriveExpected)
+      };
+    }
+    if (def.tag === "not") {
+      const body = directFixedLexNode(def.parser, resolve, active, true);
+      return body === void 0 ? void 0 : {
+        kind: "not",
+        body,
+        expected: assertionFailureExpected(false, def.parser._tag)
+      };
+    }
+    if (def.tag === "optional") {
+      const body = directFixedLexNode(def.parser, resolve, active, pureOnly);
+      return body === void 0 ? void 0 : { kind: "optional", body };
+    }
+    return void 0;
+  } finally {
+    active.delete(current);
+  }
+}
+function directFixedTokenBody(parser2, resolve) {
+  const body = directTokenBodyParser(parser2, resolve);
+  if (body === void 0) return void 0;
+  const root = directFixedLexNode(body, resolve, /* @__PURE__ */ new Set());
+  return root === void 0 ? void 0 : { kind: "fixed-tree", root };
+}
+function directBalancedTokenBody(parser2, resolve) {
+  if (directTokenBodyParser(parser2, resolve) === void 0) return void 0;
+  const spec = balancedSpecOf(parser2);
+  return spec === void 0 ? void 0 : {
+    kind: "balanced-scan",
+    open: spec.open,
+    close: spec.close,
+    raw: spec.raw,
+    strict: spec.strict,
+    ownSkip: spec.ownSkip
+  };
+}
+function directExecutableTokenBody(parser2, resolve) {
+  return directOptionalSuffixTokenBody(parser2, resolve) ?? directTerminalTokenBody(parser2, resolve) ?? directOrdered4TokenBody(parser2, resolve) ?? directNot2TokenBody(parser2, resolve) ?? directBalancedTokenBody(parser2, resolve) ?? directFixedTokenBody(parser2, resolve);
+}
+function winnerWrapsReference(winner, reference) {
+  let current = winner;
+  const seen = /* @__PURE__ */ new Set();
+  while (!seen.has(current)) {
+    if (current === reference) return true;
+    seen.add(current);
+    const def = current._def;
+    if (def.tag !== "grammar" && def.tag !== "trivia") return false;
+    current = def.parser;
+  }
+  return false;
+}
+function resolvedLazyTarget(parser2, resolve) {
+  const def = parser2._def;
+  if (def.tag !== "lazy") return void 0;
+  const name = parser2._ruleName;
+  if (name !== void 0 && resolve !== void 0) {
+    const winner = resolve(name);
+    if (winner !== void 0 && !winnerWrapsReference(winner, parser2)) return winner;
+  }
+  try {
+    return def.thunk();
+  } catch {
+    return void 0;
+  }
+}
+function balancedSpecOf(parser2) {
+  let current = parser2;
+  let spec = current._balancedSpec;
+  const seen = /* @__PURE__ */ new Set();
+  while (spec === void 0 && current._def.tag === "token" && !seen.has(current)) {
+    seen.add(current);
+    current = current._def.parser;
+    spec = current._balancedSpec;
+  }
+  return spec;
+}
+
+// src/table/encode.ts
+function emittableConst(v) {
+  const scalar = (x) => x === null || typeof x === "string" || typeof x === "number" || typeof x === "boolean";
+  if (scalar(v) || v instanceof RegExp) return true;
+  if (Array.isArray(v)) return v.every(scalar);
+  if (typeof v === "object" && v !== null) {
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null) return false;
+    return Object.values(v).every((x) => scalar(x) || Array.isArray(x) && x.every(scalar));
+  }
+  return false;
 }
 var UnsupportedConstruct = class extends Error {
   tag;
@@ -4480,6 +5509,10 @@ var Encoder = class {
   fx = [];
   disp = [];
   dsp = [];
+  lex = [];
+  lexIndex = /* @__PURE__ */ new Map();
+  lexPrograms = [];
+  lexProgramIndex = /* @__PURE__ */ new Map();
   labels = void 0;
   /** Trivia table in scope at the row being encoded — codegen's `ctx.activeTrivia`. */
   activeTrivia = void 0;
@@ -4550,6 +5583,146 @@ var Encoder = class {
     this.triviaSpecs.push(this.triviaSpecOf(t2));
     return idx;
   }
+  lexicalBodySlot(p) {
+    if (!this.selectLexicalBodies) return void 0;
+    const body = directExecutableTokenBody(p, (name) => this.winners?.[name]);
+    if (body === void 0) return void 0;
+    const tokenDef = p._def;
+    if (tokenDef.tag !== "token") throw new Error("parseman: selected lexical body lost token boundary");
+    const matcher = (arm) => {
+      const flags2 = arm.flags.includes("y") ? arm.flags : `${arm.flags.replace(/g/g, "")}y`;
+      const regex3 = this.constant(new RegExp(arm.source, flags2));
+      const key2 = `${regex3}:-1`;
+      const prior2 = this.lexIndex.get(key2);
+      if (prior2 !== void 0) return prior2;
+      const id2 = this.lex.length;
+      this.lexIndex.set(key2, id2);
+      this.lex.push([regex3, -1]);
+      return id2;
+    };
+    if (body.kind === "balanced-scan") {
+      const scan = this.scanSlot({
+        kind: 1,
+        flags: (body.raw ? 1 : 0) | (body.strict ? 4 : 0),
+        skip: body.ownSkip.map((combinator) => this.subtree(combinator)),
+        open: body.open,
+        close: body.close
+      });
+      const words = [scan];
+      const spec = [3, lexProgramDigest(words), scan];
+      const key2 = spec.join(",");
+      const prior2 = this.lexProgramIndex.get(key2);
+      if (prior2 !== void 0) return { kind: "program", program: prior2 };
+      const id2 = this.lexPrograms.length;
+      this.lexProgramIndex.set(key2, id2);
+      this.lexPrograms.push(spec);
+      return { kind: "program", program: id2 };
+    }
+    if (body.kind === "fixed-tree") {
+      const words = [];
+      const emitNode = (node2) => {
+        switch (node2.kind) {
+          case "terminal":
+            words.push(
+              LEX_NODE_TERMINAL,
+              matcher(node2.terminal),
+              this.expected(node2.terminal.expected),
+              this.track ? 1 : 0
+            );
+            return true;
+          case "sequence": {
+            for (const part of node2.parts) if (!emitNode(part)) return false;
+            const op = node2.parts.length === 2 ? LEX_NODE_SEQUENCE2 : node2.parts.length === 3 ? LEX_NODE_SEQUENCE3 : node2.parts.length === 4 ? LEX_NODE_SEQUENCE4 : node2.parts.length === 5 ? LEX_NODE_SEQUENCE5 : -1;
+            if (op < 0) return false;
+            words.push(op);
+            return true;
+          }
+          case "choice": {
+            for (const arm of node2.arms) if (!emitNode(arm)) return false;
+            const op = node2.arms.length === 2 ? LEX_NODE_CHOICE2 : node2.arms.length === 4 ? LEX_NODE_CHOICE4 : node2.arms.length === 8 ? LEX_NODE_CHOICE8 : -1;
+            if (op < 0) return false;
+            words.push(op, this.expected(node2.expected));
+            for (let i = 0; i < node2.arms.length; i++) {
+              const first = node2.firstSets[i];
+              words.push(first.kind === "ranges" ? this.charClass(first) : -1);
+              words.push(this.expected(node2.armExpected[i]));
+            }
+            return true;
+          }
+          case "not":
+            if (!emitNode(node2.body)) return false;
+            words.push(LEX_NODE_NOT, this.expected(node2.expected));
+            return true;
+          case "optional":
+            if (!emitNode(node2.body)) return false;
+            words.push(LEX_NODE_OPTIONAL);
+            return true;
+        }
+      };
+      if (!emitNode(body.root)) return void 0;
+      const spec = [2, lexProgramDigest(words), ...words];
+      const key2 = spec.join(",");
+      const prior2 = this.lexProgramIndex.get(key2);
+      if (prior2 !== void 0) return { kind: "program", program: prior2 };
+      const id2 = this.lexPrograms.length;
+      this.lexProgramIndex.set(key2, id2);
+      this.lexPrograms.push(spec);
+      return { kind: "program", program: id2 };
+    }
+    if (body.kind === "not2-ordered4-terminal") {
+      const words = [
+        ...body.guard0.map(matcher),
+        this.expected(body.guard0Expected),
+        matcher(body.guard1),
+        this.expected(body.guard1Expected),
+        matcher(body.terminal),
+        this.expected(body.terminalExpected),
+        this.track ? 1 : 0
+      ];
+      const spec = [1, lexProgramDigest(words), ...words];
+      const key2 = spec.join(",");
+      const prior2 = this.lexProgramIndex.get(key2);
+      if (prior2 !== void 0) return { kind: "program", program: prior2 };
+      const id2 = this.lexPrograms.length;
+      this.lexProgramIndex.set(key2, id2);
+      this.lexPrograms.push(spec);
+      return { kind: "program", program: id2 };
+    }
+    if (body.kind === "ordered4-terminals") {
+      const commonClass = this.charClass(body.commonFirstSet);
+      if (commonClass < 0) return void 0;
+      const words = [commonClass, this.expected(body.commonMissExpected)];
+      for (const arm of body.arms) {
+        words.push(matcher(arm), this.expected(arm.expected));
+      }
+      words.push(this.track ? 1 : 0);
+      const spec = [0, lexProgramDigest(words), ...words];
+      const key2 = spec.join(",");
+      const prior2 = this.lexProgramIndex.get(key2);
+      if (prior2 !== void 0) return { kind: "program", program: prior2 };
+      const id2 = this.lexPrograms.length;
+      this.lexProgramIndex.set(key2, id2);
+      this.lexPrograms.push(spec);
+      return { kind: "program", program: id2 };
+    }
+    const expectedFx = this.expected(body.expected);
+    const flags = body.flags.includes("y") ? body.flags : `${body.flags.replace(/g/g, "")}y`;
+    const regex2 = this.constant(new RegExp(body.source, flags));
+    const suffix = body.kind === "regex-terminal" ? -1 : body.suffix.charCodeAt(0);
+    const key = `${regex2}:${suffix}`;
+    const prior = this.lexIndex.get(key);
+    const suffixFx = this.expected(body.kind === "regex-terminal" ? [] : directTerminalFailureExpected({
+      tag: "literal",
+      value: body.suffix,
+      caseInsensitive: false
+    }));
+    const lineFlags = this.track ? body.kind === "regex-terminal" ? 1 : 1 | 2 | 4 : body.kind === "regex-terminal" ? 0 : 4;
+    if (prior !== void 0) return { kind: "body", body: prior, expectedFx, suffixFx, lineFlags };
+    const id = this.lex.length;
+    this.lexIndex.set(key, id);
+    this.lex.push([regex2, suffix]);
+    return { kind: "body", body: id, expectedFx, suffixFx, lineFlags };
+  }
   triviaSpecOf(t2) {
     const unlowered = (why) => {
       this.runtimeOnly.add(`rules({ trivia }) \u2014 ${why}`);
@@ -4633,6 +5806,9 @@ var Encoder = class {
   settings;
   /** Resolved once, HERE, at table-build time — never consulted at run time. */
   track;
+  /** TOKEN bodies are an all-program decision. A complete occurrence inside an
+   * otherwise incomplete final graph stays on CHARACTER with every sibling. */
+  selectLexicalBodies;
   /**
    * Decides the extra operands laid down below. ALWAYS TRUE — see
    * `TableSettings.recovery`. Kept as a field rather than folded away because it
@@ -4640,9 +5816,10 @@ var Encoder = class {
    * row is stated.
    */
   rec;
-  constructor(settings) {
+  constructor(settings, selectLexicalBodies) {
     this.settings = settings;
     this.track = settings.trackLines === true;
+    this.selectLexicalBodies = selectLexicalBodies;
     this.rec = true;
     this.plan = settings.coverage;
     this.cov = settings.coverage === void 0 ? void 0 : settings.coverage.definitions.map((d) => [d.id, covKindCode(d.kind)]);
@@ -4757,6 +5934,13 @@ var Encoder = class {
     this.ccIndex.set(spec, i);
     return i;
   }
+  /** Bind a guard only when its class is already part of the program. Repeat
+   * gating must not grow the compact artifact merely to avoid a failed call. */
+  existingCharClass(fs) {
+    if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
+    const hit = this.ccIndex.get(encodeClassSpec(fs.ranges));
+    return hit !== void 0 && hit < 100 ? hit : -1;
+  }
   /**
    * Wrap one choice arm in its `autoNot` checks (`OP_REJECT`).
    *
@@ -4845,7 +6029,7 @@ var Encoder = class {
    * in the target rule's own ambient trivia when that differs from the trivia
    * lexically active at the reference.
    *
-   * `encodeRule` wraps a rule ENTRY in `OP_SCOPE`, but only the entry: a `g.X`
+   * `encodeRule` wraps a rule ENTRY in `OP_SCOPE_PLAIN`, but only the entry: a `g.X`
    * reference resolves straight to the body's offset and jumps past it (the note
    * at `encodeRule`). So a rule referenced from inside a `noTrivia(...)` region ran
    * with NO ambient trivia of its own — the table scoped trivia DYNAMICALLY, by
@@ -4922,6 +6106,19 @@ var Encoder = class {
   }
   encodeDef(p) {
     const d = p._def;
+    if (d.tag === "token") {
+      const selected = this.lexicalBodySlot(p);
+      if (selected !== void 0) {
+        if (selected.kind === "program") return this.emit(OP_LEX_PROGRAM, selected.program);
+        return this.emit(
+          OP_LEX_BODY,
+          selected.body,
+          selected.expectedFx,
+          selected.suffixFx,
+          selected.lineFlags
+        );
+      }
+    }
     const bal = p._balancedSpec;
     if (bal !== void 0) return this.emit(OP_SCAN, this.scanSlot({
       kind: 1,
@@ -4943,13 +6140,13 @@ var Encoder = class {
     switch (d.tag) {
       case "literal": {
         if (d.caseInsensitive) {
-          return this.emit(this.track ? OP_LIT_CI_TRACK : OP_LIT_CI, this.constant(d.value), this.expected(deriveExpected(p)));
+          return this.emit(this.track ? OP_LIT_CI_TRACK : OP_LIT_CI, this.constant(d.value), this.expected(directTerminalFailureExpected(d)));
         }
-        return this.emit(this.track ? OP_LIT_TRACK : OP_LIT, this.constant(d.value), this.expected(deriveExpected(p)));
+        return this.emit(this.track ? OP_LIT_TRACK : OP_LIT, this.constant(d.value), this.expected(directTerminalFailureExpected(d)));
       }
       case "regex": {
         const flags = d.flags.includes("y") ? d.flags : `${d.flags}y`;
-        return this.emit(this.track ? OP_RX_TRACK : OP_RX, this.constant(new RegExp(d.source, flags)), this.expected(deriveExpected(p)));
+        return this.emit(this.track ? OP_RX_TRACK : OP_RX, this.constant(new RegExp(d.source, flags)), this.expected(directTerminalFailureExpected(d)));
       }
       case "keywords": {
         const alt = d.words.map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
@@ -4963,7 +6160,7 @@ var Encoder = class {
           // failing keyword arm names the CATEGORY rather than reciting every
           // literal in the family. `deriveExpected` reports the literals, so the
           // table said `'"media"'` where both other engines say `'keyword'`.
-          this.expected(["keyword"])
+          this.expected(directTerminalFailureExpected(d))
         );
       }
       case "expect": {
@@ -5010,7 +6207,8 @@ var Encoder = class {
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
         const rr = this.refResolver();
-        const classes = arms.map((a) => matchesEmpty(a, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(a, /* @__PURE__ */ new Set(), rr)));
+        const finalChoice = classifyFinalChoice(arms, rr);
+        const classes = arms.map((_, i) => finalChoice.nullable[i] ? -1 : this.charClass(finalChoice.firstSets[i]));
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         const head = this.emitHead(OP_CHOICE, 3 + 2 * kids.length);
@@ -5026,9 +6224,11 @@ var Encoder = class {
       case "many":
       case "oneOrMore": {
         const child = this.node(d.parser).ip;
+        const rr = this.refResolver();
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.existingCharClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr));
         const op = d.valueUnused ? OP_REPV : OP_REP;
         const min = d.tag === "many" ? 0 : d.min;
-        return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), -1) : this.emit(op, child, min, d.max ?? -1, -1, 0);
+        return this.rec ? this.emit(op, child, min, d.max ?? -1, -1, 0, this.expected(deriveExpected(d.parser)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
       }
       case "sepBy": {
         const child = this.node(d.parser).ip;
@@ -5055,7 +6255,8 @@ var Encoder = class {
         if (inner.tag === "sequence" && !this.memo.has(d.parser) && !this.pending.has(d.parser)) {
           const kids = inner.parsers.map((c) => this.node(c).ip);
           const head = this.emitHead(OP_SEQX, 2 + kids.length + (this.rec ? kids.length : 0));
-          this.code[head + 1] = this.fn(d.fn, d.fnSrc ?? null);
+          const projection = directArrayProjection(d.fn, d.fnSrc, kids.length);
+          this.code[head + 1] = projection === null ? this.fn(d.fn, d.fnSrc ?? null) : ~projection;
           this.code[head + 2] = kids.length;
           for (let i = 0; i < kids.length; i++) this.code[head + 3 + i] = kids[i];
           if (this.rec) {
@@ -5076,10 +6277,11 @@ var Encoder = class {
         const cstOut = this.settings.hostMode === "cst";
         const noBuildCaptures = d.project === void 0;
         const derivedTrivia = d.build !== void 0 ? buildReadsTrivia(d) : noBuildCaptures;
+        const omitsRaw = d.build !== void 0 && !buildReadsRaw(d);
         const derivedState = d.build !== void 0 ? buildReadsState(d) : noBuildCaptures;
         const derivedFields = d.build !== void 0 ? buildReadsFields(d) : noBuildCaptures;
         const wantsFields = parserHasOwnFields(d.parser) && (cstOut || derivedFields);
-        const flags = (cstOut || d.captureTrivia === true || d.trailingTrivia === true || derivedTrivia ? 4 : 0) | (cstOut || derivedState ? 8 : 0) | (wantsFields ? 16 : 0) | (d.collapse === true ? 32 : 0) | (d.unwrap === true ? 64 : 0) | (d.trailingTrivia === true ? 128 : 0) | (d.captureTrivia === true ? 1 : 0);
+        const flags = (cstOut || d.captureTrivia === true || d.trailingTrivia === true || derivedTrivia ? 4 : 0) | (!cstOut && omitsRaw ? 2 : 0) | (cstOut || derivedState ? 8 : 0) | (wantsFields ? 16 : 0) | (d.collapse === true ? 32 : 0) | (d.unwrap === true ? 64 : 0) | (d.trailingTrivia === true ? 128 : 0) | (d.captureTrivia === true ? 1 : 0);
         const body = this.emit(
           this.track ? OP_NODE_TRACK : OP_NODE,
           d.build === void 0 ? -1 : this.fn(d.build, d.buildSrc ?? null),
@@ -5100,8 +6302,9 @@ var Encoder = class {
         const e = deriveExpected(d.parser);
         return this.emit(OP_GATE, cls, body, this.expected(e.length > 0 ? e : [d.parser._tag]));
       }
-      case "token":
+      case "token": {
         return this.emit(OP_TOKEN, this.node(d.parser).ip);
+      }
       case "routed":
         return this.emit(OP_ROUTED, d.fallback === void 0 ? -1 : this.node(d.fallback).ip);
       case "dispatch": {
@@ -5166,7 +6369,7 @@ var Encoder = class {
       case "lazy": {
         const refName = p._ruleName;
         const winner = refName === void 0 ? void 0 : this.winners?.[refName];
-        if (winner !== void 0 && !wrapsRef(winner, p)) return this.scopedRef(p, winner);
+        if (winner !== void 0 && !winnerWrapsReference2(winner, p)) return this.scopedRef(p, winner);
         let resolved;
         try {
           resolved = d.thunk();
@@ -5182,7 +6385,7 @@ var Encoder = class {
       // other engine reported `['not(literal)']`. It hid because `expected` is a
       // TOP-LEVEL field on `RunResult` and is NOT part of the identity digest.
       case "not":
-        return this.emit(OP_NOT, this.node(d.parser).ip, this.expected([`not(${d.parser._tag})`]));
+        return this.emit(OP_NOT, this.node(d.parser).ip, this.expected(assertionFailureExpected(false, d.parser._tag)));
       case "guard":
         return this.emit(OP_GUARD, this.fn(d.predicate, d.predSrc ?? null), this.expected(["gate"]));
       case "adjacency":
@@ -5200,7 +6403,7 @@ var Encoder = class {
         return this.emit(OP_WITHCTX, this.constant(d.extra), this.node(d.parser).ip);
       }
       case "peek":
-        return this.emit(OP_PEEK, this.node(d.parser).ip, this.expected([`peek(${d.parser._tag})`]));
+        return this.emit(OP_PEEK, this.node(d.parser).ip, this.expected(assertionFailureExpected(true, d.parser._tag)));
       // A TRANSACTION IS A ROW. See `OP_ATTEMPT` for why the transparent
       // lowering was correct only for a choice arm.
       case "attempt": {
@@ -5361,6 +6564,8 @@ var Encoder = class {
       disp: this.disp,
       dsp: this.dsp,
       rules: this.rules,
+      ...this.lex.length === 0 ? {} : { lex: this.lex },
+      ...this.lexPrograms.length === 0 ? {} : { lexPrograms: this.lexPrograms },
       ...this.labels === void 0 ? {} : { labels: this.labels },
       ...this.classified ? { classified: 1 } : {},
       ...this.scanSkipSets.length === 0 ? {} : { scanSkip: this.scanSkipSets, scanSkipOf: this.scanSkipOf },
@@ -5412,7 +6617,11 @@ function encodeTableProgram(ruleMap, settings = {}) {
     ...hostMode === void 0 ? {} : { hostMode },
     ...track ? { trackLines: true } : {}
   };
-  const enc = new Encoder(resolvedSettings);
+  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]);
   const prog = enc.finish();
@@ -6457,6 +7666,8 @@ function childSlots(code, ip, out) {
     case OP_GUARD:
     case OP_ADJ:
     case OP_LIVE:
+    case OP_LEX_BODY:
+    case OP_LEX_PROGRAM:
       return true;
     // Single child at `ip + 1`. `OP_COV` is a wrapper on the same footing as the
     // rest — a coverage-encoded program is a program, and omitting it made
@@ -6574,7 +7785,12 @@ function transfer(code, ip, at, hostCst) {
     return { tri, buf: at.buf, cap };
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
-    const cap = (code[ip + 3] & 4) !== 0 || hostCst ? CAP_ON : CAP_OFF;
+    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 };
+    }
+    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 };
   }
@@ -6615,6 +7831,43 @@ function computeSiteLabels(code, roots, hostCst) {
   return { at: (ip) => labels.get(ip) ?? TOP };
 }
 
+// src/table/scalar-terminal.ts
+function makeScalarRecognizer(op, spec) {
+  if (op === OP_RX && spec instanceof RegExp) {
+    return (input, pos) => {
+      spec.lastIndex = pos;
+      return spec.test(input) ? spec.lastIndex : -1;
+    };
+  }
+  if (op !== OP_LIT || typeof spec !== "string") return void 0;
+  const len = spec.length;
+  if (len === 1) {
+    const c0 = spec.charCodeAt(0);
+    return (input, pos) => input.charCodeAt(pos) === c0 ? pos + 1 : -1;
+  }
+  if (len === 2) {
+    const c0 = spec.charCodeAt(0), c1 = spec.charCodeAt(1);
+    return (input, pos) => input.charCodeAt(pos) === c0 && input.charCodeAt(pos + 1) === c1 ? pos + 2 : -1;
+  }
+  if (len === 3) {
+    const c0 = spec.charCodeAt(0), c1 = spec.charCodeAt(1), c2 = spec.charCodeAt(2);
+    return (input, pos) => input.charCodeAt(pos) === c0 && input.charCodeAt(pos + 1) === c1 && input.charCodeAt(pos + 2) === c2 ? pos + 3 : -1;
+  }
+  return (input, pos) => input.startsWith(spec, pos) ? pos + len : -1;
+}
+function scalarTerminalNodeChild(code, ip) {
+  if (code[ip + 1] < 0 || code[ip + 3] !== 0 || code[ip + 4] !== -1) return -1;
+  const child = code[ip + 2];
+  const op = code[child];
+  return op === OP_RX || op === OP_LIT ? child : -1;
+}
+function scalarTerminalNotChild(code, ip) {
+  if (code[ip] !== OP_NOT) return -1;
+  const child = code[ip + 1];
+  const op = code[child];
+  return op === OP_RX || op === OP_LIT ? child : -1;
+}
+
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
   construct;
@@ -6676,7 +7929,19 @@ var EMITTED_PARAMS = [
   "matchesAt",
   "recoverScan",
   "orSentinel",
-  "captureError"
+  "captureError",
+  // Pure scalar terminal recognizers, indexed by the terminal's existing const
+  // operand. Appended for compatibility with older precompiled factories.
+  "RECOG",
+  // Appended so precompiled factories produced by earlier runtimes keep every
+  // positional helper binding. Older factories ignore this trailing argument.
+  "commitTriviaScan",
+  "scanTriviaCompact",
+  "LEX",
+  // Appended for old precompiled-factory ABI: old factories ignore it.
+  "adjacencyHolds",
+  // Appended for selected composite lexical programs; old factories ignore it.
+  "LEXPROG"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -6687,7 +7952,7 @@ 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)
 if(s!==null)return skipTriviaScanned(s,input,cur,ctx)
-if(needsDeferredTriviaCommit(ctx)){const sc=scanTrivia(input,cur,ctx);sc.commit();return sc.end}
+if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
 return advanceTrivia(input,cur,ctx)
 }
 function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
@@ -6701,6 +7966,13 @@ if(b.raw!==undefined)b.raw.push(l)
 else if(b.rawSingle!==undefined){b.raw=[b.rawSingle,l];b.rawSingle=undefined}
 else b.rawSingle=l
 }
+function _capturedFlatChildren(children){
+if(children.length===0)return EMPTY_CH
+if(children[0]!==undefined)return children
+let first=1
+while(first<children.length&&children[first]===undefined)first++
+return first===children.length?EMPTY_CH:children.slice(first)
+}
 function _accSet(ax,acc){
 if(ax===undefined||ax.length===0)return acc
 if(acc===undefined)return ax.slice()
@@ -6835,12 +8107,16 @@ function maskForClassRow(gates) {
   }
   return m;
 }
-function rebuildPools(cc, fx, plan) {
+function rebuildPools(cc, fx, disp, plan) {
   const classes = plan.classes.map((row) => row.map((i) => i < 0 ? null : cc[i] ?? null));
   return {
     classes,
     armExpected: plan.armExpected.map((row) => row.map((i) => fx[i] ?? [])),
-    masks: plan.masks.map((ci) => maskForClassRow(classes[ci]))
+    masks: plan.masks.map((source) => {
+      const row = source >= 0 ? classes[source] : disp[~source]?.armCls;
+      if (row === void 0) throw new TypeError(`table emitter: invalid MASK plan source ${source}`);
+      return maskForClassRow(row);
+    })
   };
 }
 function emitAssemblySource(t2, prog, cfg, extraIps = []) {
@@ -6851,6 +8127,14 @@ function emitAssemblySource(t2, prog, cfg, extraIps = []) {
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
   const labels = computeSiteLabels(code, roots, hostCst);
+  const scalarSpecs = /* @__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]);
+    }
+  }
   const sinks = (() => {
     let fd = false;
     let er = REC;
@@ -6871,6 +8155,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = []) {
   const reached = /* @__PURE__ */ new Set();
   const prelude = [];
   const skipDefs = [];
+  const choiceDefs = [];
   const skipPool = /* @__PURE__ */ new Map();
   const pool = /* @__PURE__ */ new Map();
   const masks = [];
@@ -6890,6 +8175,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = []) {
   const kRef = (i) => hoist("k", `K[${i}]`);
   const fxRef = (i) => hoist("fx", `FX[${i}]`);
   const fnRef = (i) => hoist("fn", `FNS[${i}]`);
+  const recognizerRef = (i) => hoist("rec", `RECOG[${i}]`);
   const sentRef = (cls) => cls < 0 ? "undefined" : hoist("sent", `SENTS[${cls}]`);
   let uid = 0;
   const tmp = () => `_t${uid++}_`;
@@ -6903,8 +8189,8 @@ function emitAssemblySource(t2, prog, cfg, extraIps = []) {
     const nm = `_sk${skipPool.size}`;
     skipPool.set(key, nm);
     if (!hasScan) {
-      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){const s=scanTrivia(input,cur,ctx);s.commit();return s.end}` : `function ${nm}(input,cur,ctx){
-if(needsDeferredTriviaCommit(ctx)){const s=scanTrivia(input,cur,ctx);s.commit();return s.end}
+      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return commitTriviaScan(scanTriviaCompact(input,cur,ctx))}` : `function ${nm}(input,cur,ctx){
+if(needsDeferredTriviaCommit(ctx))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
 return advanceTrivia(input,cur,ctx)}`);
       return nm;
     }
@@ -6991,6 +8277,19 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         const s = k[code[ip + 1]];
         const xf = fxRef(code[ip + 2]);
         const track = op === OP_LIT_TRACK;
+        if (!track && scalarSpecs.has(code[ip + 1])) {
+          const recognize = recognizerRef(code[ip + 1]);
+          return `${head}
+const e=${recognize}(input,pos)
+if(e>=0){
+${captureLeaf(q(s))}
+EC.e=e
+return ${q(s)}
+}
+ctx._fe=pos;ctx._fx=${xf}
+return FAIL
+}`;
+        }
         const test = s.length === 1 ? `input.charCodeAt(pos)===${s.charCodeAt(0)}` : s.length === 2 ? `input.charCodeAt(pos)===${s.charCodeAt(0)}&&input.charCodeAt(pos+1)===${s.charCodeAt(1)}` : `input.startsWith(${q(s)},pos)`;
         return `${head}
 if(${test}){
@@ -7040,6 +8339,20 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
       case OP_RX_TRACK: {
         const xf = fxRef(code[ip + 2]);
         const track = op === OP_RX_TRACK;
+        if (!track && scalarSpecs.has(code[ip + 1])) {
+          const recognize = recognizerRef(code[ip + 1]);
+          return `${head}
+const e=${recognize}(input,pos)
+if(e>=0){
+const v=input.slice(pos,e)
+${captureLeaf("v")}
+EC.e=e
+return v
+}
+ctx._fe=pos;ctx._fx=${xf}
+return FAIL
+}`;
+        }
         const scanned = emitScan(code[ip + 1], xf, track, captureLeaf);
         if (scanned !== void 0) return `${head}${scanned}}`;
         const rxk = k[code[ip + 1]];
@@ -7201,6 +8514,73 @@ const out=${isToken ? "input.slice(pos,e)" : `${fn}(v,{start:pos,end:e})`}
 if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:out,span:{start:pos,end:e}})
 EC.e=e
 return out
+}`;
+      }
+      case OP_LEX_BODY: {
+        const recognize = hoist("lex", `LEX[${code[ip + 1]}]`);
+        const expected = fxRef(code[ip + 2]);
+        const suffixExpected = fxRef(code[ip + 3]);
+        const lineFlags = code[ip + 4];
+        const hasSuffix = (lineFlags & 4) !== 0;
+        return `${head}
+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)
+if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+EC.e=e
+return v
+}`;
+      }
+      case OP_LEX_PROGRAM: {
+        const programId = code[ip + 1];
+        const run = hoist("lexProgram", `LEXPROG[${programId}]`);
+        const scanId = t2.lexPrograms[programId].scan;
+        if (scanId !== void 0) return `${head}
+const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan
+const sBuf=ctx._cstBuf,sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sOtl=ctx._triviaLog,sRtl=ctx._rootTriviaLog
+const wasCap=ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined
+_pfScan=null
+ctx.trivia=undefined
+ctx.triviaKindLabels=undefined
+ctx._cstBuf=undefined
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined
+ctx._triviaLog=undefined
+ctx._rootTriviaLog=undefined
+let e
+try{e=${run}(input,pos,ctx,SCANS[${scanId}])}finally{
+_pfScan=sScan
+ctx.trivia=sTri
+ctx.triviaKindLabels=sKinds
+ctx._cstBuf=sBuf
+ctx._cstChildren=sCh
+ctx._cstLeaves=sLv
+ctx._cstRawChildren=sRaw
+ctx._cstTriviaLog=sTl
+ctx._triviaLog=sOtl
+ctx._rootTriviaLog=sRtl
+}
+if(e<0)return FAIL
+const v=input.slice(pos,e)
+if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+EC.e=e
+return v
+}`;
+        return `${head}
+const e=${run}(input,pos,ctx)
+if(e<0)return FAIL
+const v=input.slice(pos,e)
+if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
+EC.e=e
+return v
 }`;
       }
       /* ── transaction ─────────────────────────────────────────────────────── */
@@ -7218,6 +8598,18 @@ return FAIL
 }`;
       }
       case OP_NOT: {
+        const scalarChild = scalarTerminalNotChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = recognizerRef(code[scalarChild + 1]);
+          const xf2 = fxRef(code[ip + 2]);
+          return `${head}
+if(${recognize}(input,pos)<0){EC.e=pos;return null}
+ctx._fe=pos
+ctx._fx=${xf2}
+EC.e=pos
+return FAIL
+}`;
+        }
         const child = link(code[ip + 1]);
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
@@ -7267,14 +8659,14 @@ return v
         const base = fused ? ip + 3 : ip + 2;
         const n = code[fused ? ip + 2 : ip + 1];
         const wantValues = op !== OP_SEQV;
-        for (let i = 1; i < n; i++) {
-          if (code[code[base + i]] === OP_ADJ) {
-            throw new Unemittable("a sequence carrying an adjacency assertion (OP_ADJ)");
-          }
-        }
-        const fn = fused ? fnRef(code[ip + 1]) : void 0;
+        const reducer = fused ? code[ip + 1] : -1;
+        const projection = reducer < 0 ? ~reducer : -1;
+        const fn = fused && projection < 0 ? fnRef(reducer) : void 0;
         const kids = [];
-        for (let i = 0; i < n; i++) kids.push(link(code[base + i]));
+        for (let i = 0; i < n; i++) {
+          const childIp = code[base + i];
+          kids.push(code[childIp] === OP_ADJ ? "" : link(childIp));
+        }
         const sy = REC ? `${tmp()}sy` : "";
         const pub = (i) => {
           const s = sentRef(code[base + n + i]);
@@ -7288,7 +8680,7 @@ return v
 }` : `${parts.join("\n")}
 }`;
         if (n === 1) {
-          parts.push(fused ? `return ${fn}([v0],{start:pos,end:EC.e})` : wantValues ? "return [v0]" : "return undefined");
+          parts.push(fused ? projection === 0 ? "return v0" : `return ${fn}([v0],{start:pos,end:EC.e})` : wantValues ? "return [v0]" : "return undefined");
           return close();
         }
         parts.push("let cur=EC.e");
@@ -7297,11 +8689,21 @@ return v
           const vn = `v${i}`;
           parts.push(`let ${vn}`);
           if (REC) parts.push(pub(i));
-          parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L)));
+          const childIp = code[base + i];
+          if (code[childIp] === OP_ADJ) {
+            const negated = code[childIp + 1] === 1;
+            const ki = code[childIp + 2];
+            const kinds = ki < 0 ? "undefined" : `K[${ki}]`;
+            const expected = fxRef(code[childIp + 3]);
+            parts.push(
+              `if(!adjacencyHolds(input,cur,ctx,${negated ? "true" : "false"},${kinds})){ctx._fe=cur;ctx._fx=${expected};return FAIL}`,
+              `${vn}=null`
+            );
+          } else parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L)));
           names.push(vn);
         }
         parts.push("EC.e=cur");
-        parts.push(fused ? `return ${fn}([${names.join(",")}],{start:pos,end:cur})` : wantValues ? `return [${names.join(",")}]` : "return undefined");
+        parts.push(fused ? projection >= 0 ? `return ${names[projection]}` : `return ${fn}([${names.join(",")}],{start:pos,end:cur})` : wantValues ? `return [${names.join(",")}]` : "return undefined");
         return close();
       }
       case OP_CHOICE: {
@@ -7311,11 +8713,6 @@ return v
         const base = ip + 4;
         const arms = [];
         for (let i = 0; i < n; i++) arms.push(link(code[base + i]));
-        const axi = armExpected.push(
-          Array.from({ length: n }, (_, i) => t2.fx[code[base + n + i]])
-        ) - 1;
-        armExpectedPlan.push(Array.from({ length: n }, (_, i) => code[base + n + i]));
-        const afx = hoist("afx", `AFX[${axi}]`);
         if (table.exclusive) {
           const di = code[ip + 1];
           const asc = hoist("as", `DISP[${di}].ascii`);
@@ -7342,38 +8739,43 @@ ctx._fe=pos;ctx._fx=${choiceFx}
 return FAIL
 }`;
         }
-        const ci = classes.push(Array.from({ length: n }, (_, i) => table.armCls[i] ?? null)) - 1;
-        classPlan.push(Array.from({ length: n }, (_, i) => prog.disp[code[ip + 1]][i] ?? -1));
-        const gates = classes[ci];
-        const gRef = hoist("g", `CLS[${ci}]`);
-        const maskable = n <= 32;
-        let maskName = "";
-        if (maskable) {
-          maskName = hoist("mk", `MASK[${masks.push(maskForClassRow(gates)) - 1}]`);
-          maskPlan.push(ci);
-        }
-        const p = tmp();
-        const maskArms = arms.map((a, i) => `
-if((bits&${1 << i})!==0){
+        {
+          const di = code[ip + 1];
+          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 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 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){
 ctx._fc=false
-{const v=${a}(input,pos,ctx)
+{const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
-for(let j=prev;j<${i};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+acc=${catchName}(${i},prev,acc)
 prev=${i + 1}
 acc=_accSet(ctx._fx,acc)
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
-}`).join("");
-        const generalArms = arms.map((a, i) => `
-if(${gRef}[${i}]===null||classHas(${gRef}[${i}],c)){
+}`;
+          }).join("\n") : "";
+          const generalArms = arms.map((arm, i) => `if(${gateRefs[i]}===null||classHas(${gateRefs[i]},c)){
 ctx._fc=false
-{const v=${a}(input,pos,ctx)
+{const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 acc=_accSet(ctx._fx,acc)
 if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
 ${emitRollback(p, L.buf, sinks)}
-}else acc=_accSet(${afx}[${i}],acc)`).join("");
-        return `${head}
+}else acc=_accSet(${expected[i]},acc)`).join("\n");
+          return `${head}
 const c=lead(input,pos)
 ${emitMark(p, L.buf, sinks)}
 let acc
@@ -7381,14 +8783,16 @@ ${maskable ? `if(c<128){
 const bits=${maskName}[c<0?128:c]
 let prev=0
 ${maskArms}
-for(let j=prev;j<${n};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+acc=${catchName}(${n},prev,acc)
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL
 }
-` : ""}${generalArms}
+` : ""}
+${generalArms}
 ctx._fe=pos;ctx._fx=acc??${choiceFx}
 return FAIL
 }`;
+        }
       }
       case OP_DISPATCH: {
         const di = code[ip + 2];
@@ -7414,8 +8818,16 @@ return FAIL
               return `asciiFoldKey(key).startsWith(${q(m[1])})`;
             case 4:
               return `asciiFoldKey(key).endsWith(${q(m[1])})`;
-            default:
+            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){
@@ -7473,6 +8885,15 @@ return [key,v]
         const reportItem = (flags & 4) !== 0;
         const itemFx = reportItem ? fxRef(code[ip + 6]) : "EMPTY_FX";
         const collect = op === OP_REP;
+        let itemCls;
+        if (!REC) {
+          const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
+          if (itemClassIndex >= 0) {
+            const ci = classes.push([t2.cc[itemClassIndex]]) - 1;
+            classPlan.push([itemClassIndex]);
+            itemCls = hoist("ri", `CLS[${ci}][0]`);
+          }
+        }
         const skipBeforeFirst = sepIp < 0 && min === 0;
         const p = tmp();
         const via = sep !== void 0 ? "false" : min === 0 ? skipBeforeFirst ? "true" : "count>0" : `count>=${min}&&count>0`;
@@ -7480,7 +8901,6 @@ 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 needMark = L.buf ? "true" : "needMark";
         const pfd = sinks.fd ? `${p}fd` : "0";
         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 ? `
@@ -7525,11 +8945,13 @@ continue
         return `${head}
 const out=${collect ? "[]" : "undefined"}
 ${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
-` : ""}let cur=pos
+` : ""}${itemCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
+`}let cur=pos
 let count=0
 for(;;){
 ${max >= 0 ? `if(count>=${max})break
 ` : ""}${sep !== void 0 ? `if(count>0&&count>=${min}&&cur>=input.length)break
+` : ""}${itemCls !== void 0 && sep === void 0 ? `if(count>=${min}&&${p}gate&&${hasTrivia === "false" ? "true" : hasTrivia === "true" ? "false" : "!hasTrivia"}&&!classHas(${itemCls},lead(input,cur)))break
 ` : ""}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ""}${sinks.er ? `,${p}er=0` : ""}
 ${markBody}
 let itemStart=cur
@@ -7554,7 +8976,11 @@ itemStart=${hasTrivia === "false" ? "EC.e" : hasTrivia === "true" ? `${skip}(inp
 ${rb}
 ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
-ctx._fc=false
+${itemCls === void 0 ? "" : `if(count>=${min}&&${p}gate&&!classHas(${itemCls},lead(input,itemStart))){
+${rb}
+${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
+}
+`}ctx._fc=false
 const v=${child}(input,itemStart,ctx)
 if(v===FAIL){
 ${REC ? `if(ctx._fc===true){
@@ -7583,6 +9009,26 @@ return out
       case OP_NODE:
       case OP_NODE_TRACK: {
         const flags = code[ip + 3];
+        const scalarChild = scalarTerminalNodeChild(code, ip);
+        if (scalarChild >= 0 && scalarSpecs.has(code[scalarChild + 1])) {
+          const recognize = recognizerRef(code[scalarChild + 1]);
+          const spec = code[scalarChild] === OP_RX ? null : k[code[scalarChild + 1]];
+          const value2 = spec === null ? "input.slice(pos,end)" : q(spec);
+          const xf = fxRef(code[scalarChild + 2]);
+          const build2 = fnRef(code[ip + 1]);
+          return `${head}
+const end=${recognize}(input,pos)
+if(end<0){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+const value=${value2}
+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))"}
+EC.e=end
+return nd
+}`;
+        }
         const child = link(code[ip + 2]);
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
@@ -7597,6 +9043,51 @@ return out
         const unwrap = (flags & 64) !== 0;
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
+        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){
+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))
+}`;
+          return `${head}
+const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf,sFields=ctx._fields
+const flat=[]
+ctx._cstBuf=undefined
+ctx._cstChildren=flat
+ctx._cstLeaves=flat
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined
+ctx.captureTrivia=false
+ctx._fields=${fields ? "[]" : "undefined"}
+const v=${child}(input,pos,ctx)
+const captured=_capturedFlatChildren(flat)
+${fields ? "const fieldMap=buildFieldMap(ctx._fields)\n" : ""}ctx._fields=sFields
+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
+${collapseChildren ? `const nd=captured.length===1?captured[0]:${build}(captured,undefined,{start:pos,end},EMPTY_CH,EMPTY_TL,undefined)` : `const nd=${build}(captured,${fields ? "fieldMap" : "undefined"},{start:pos,end},EMPTY_CH,EMPTY_TL,undefined)`}
+${publish}
+EC.e=end
+return nd
+}`;
+        }
         const structural = build === void 0 && proj < 0;
         const grammarCapture = (flags & 1) !== 0 || trailingTrivia;
         const hostCapturesThisType = structural && cfg.hostCaptureTrivia !== void 0 ? cfg.hostCaptureTrivia(type) : void 0;
@@ -7682,6 +9173,7 @@ return nd
   const source = `${RUNTIME_PRELUDE}
 ${prelude.join("\n")}
 ${skipDefs.join("\n")}
+${choiceDefs.join("\n")}
 ${bodies.join("\n")}
 function _begin(ctx){
 const host=ctx.build
@@ -7747,7 +9239,7 @@ function literal(value, opts = {}) {
       { lo: firstUpper, hi: firstUpper }
     ] } : firstSet2;
   }
-  const expected = [JSON.stringify(value)];
+  const expected = directTerminalFailureExpected({ tag: "literal", value, caseInsensitive });
   const parse2 = !caseInsensitive && value.length === 1 ? (() => {
     const code = value.charCodeAt(0);
     return function parse3(input, pos, ctx) {
@@ -7831,9 +9323,7 @@ function sequence(...parsers) {
           const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           let scanEnd;
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
+            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
@@ -7843,7 +9333,15 @@ function sequence(...parsers) {
           const result2 = parsers[i].parse(input, scanEnd, ctx);
           if (!result2.ok) return result2;
           if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+          else rollbackScannedTriviaAt(
+            ctx,
+            mTlog,
+            scanTlog,
+            mLog,
+            scanLog,
+            mRootLog,
+            scanRootLog
+          );
           if (values !== void 0) values.push(result2.value);
           continue;
         }
@@ -7878,9 +9376,7 @@ function sequence(...parsers) {
         const mLog = ctx._triviaLog?.length ?? 0;
         const mRootLog = ctx._rootTriviaLog?.length ?? 0;
         if (needsDeferredTriviaCommit(ctx)) {
-          const scan = scanTrivia(input, cur, ctx);
-          scan.commit();
-          scanEnd = scan.end;
+          scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
         } else {
           scanEnd = advanceTrivia(input, cur, ctx);
         }
@@ -7890,7 +9386,15 @@ function sequence(...parsers) {
         const result2 = parsers[i].parse(input, scanEnd, ctx);
         if (!result2.ok) return result2;
         if (result2.span.end > scanEnd) cur = result2.span.end;
-        else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+        else rollbackScannedTriviaAt(
+          ctx,
+          mTlog,
+          scanTlog,
+          mLog,
+          scanLog,
+          mRootLog,
+          scanRootLog
+        );
         if (values !== void 0) values.push(result2.value);
         continue;
       }
@@ -7922,9 +9426,7 @@ function sequence(...parsers) {
           const mLog = ctx._triviaLog?.length ?? 0;
           const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           if (needsDeferredTriviaCommit(ctx)) {
-            const scan = scanTrivia(input, cur, ctx);
-            scan.commit();
-            scanEnd = scan.end;
+            scanEnd = commitTriviaScan(scanTriviaCompact(input, cur, ctx));
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
@@ -7936,7 +9438,15 @@ function sequence(...parsers) {
           if (result2.span.end > scanEnd) {
             cur = result2.span.end;
           } else {
-            rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
+            rollbackScannedTriviaAt(
+              ctx,
+              mTlog,
+              scanTlog,
+              mLog,
+              scanLog,
+              mRootLog,
+              scanRootLog
+            );
           }
           if (values !== void 0) values.push(result2.value);
           continue;
@@ -8296,7 +9806,7 @@ function reachableIps(prog) {
 
 // src/table/stamp.ts
 var EMPTY_FX = [];
-function committed(c) {
+function committed2(c) {
   return c._fc === true;
 }
 function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(prog)) {
@@ -8346,7 +9856,7 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
         const fe = ctx._fe;
         const at = fe === void 0 || fe < 0 ? pos : fe;
         const fspan = lines ? spanLines(ctx, at, at) : { start: at, end: at };
-        return committed(ctx) ? { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan, committed: true } : { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan };
+        return committed2(ctx) ? { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan, committed: true } : { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan };
       }
       return { ok: true, value: d.lastValue(), span: lines ? spanLines(ctx, pos, end) : { start: pos, end } };
     };
@@ -8392,11 +9902,15 @@ function linkMatcher(m) {
       return (key) => asciiFoldKey(key).startsWith(value);
     case 4:
       return (key) => asciiFoldKey(key).endsWith(value);
-    // A fresh RegExp per test, as `matchesDispatchMatcher` builds — a cached one
-    // would carry `lastIndex` across parses whenever the author's pattern was
-    // sticky or global.
     default: {
       const flags = m[2];
+      if (!flags.includes("g") && !flags.includes("y")) {
+        try {
+          const pattern = new RegExp(value, flags);
+          return (key) => pattern.test(key);
+        } catch {
+        }
+      }
       return (key) => new RegExp(value, flags).test(key);
     }
   }
@@ -8427,6 +9941,17 @@ function assemble(t2, prog, cfg) {
     return made;
   }
   const EC = newEndCell();
+  const scalarRecognizers = [];
+  const rawScalarSpecs = /* @__PURE__ */ new Set();
+  function scalarFor(child) {
+    const spec = code[child + 1];
+    let recognize = scalarRecognizers[spec];
+    if (recognize === void 0) {
+      recognize = makeScalarRecognizer(code[child], k[spec]);
+      scalarRecognizers[spec] = recognize;
+    }
+    return recognize;
+  }
   let SCAN = null;
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
@@ -8434,36 +9959,264 @@ function assemble(t2, prog, cfg) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
   }
-  function rollbackNeeded(ctx) {
-    return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0;
-  }
-  let MRAW = 0;
-  let MTL = 0;
-  let MLV = 0;
-  function markCst(ctx) {
-    const b = ctx._cstBuf;
-    if (b !== void 0) {
-      const raw = b.raw;
-      MRAW = 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;
-      MTL = tl !== void 0 ? tl.length : 0;
-      return true;
-    }
-    if (ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0) {
-      MRAW = ctx._cstRawChildren?.length ?? 0;
-      MTL = ctx._cstTriviaLog?.length ?? 0;
-      MLV = ctx._cstLeaves?.length ?? 0;
-      return true;
-    }
-    MRAW = 0;
-    MTL = 0;
-    MLV = 0;
-    return false;
+  function plainBuildNode(child, build) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const buf = {};
+      ctx._cstBuf = buf;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = void 0;
+      const value = child(input, pos, ctx);
+      const kids = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY_CH);
+      const rawKids = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY_CH);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const span = { start: pos, end };
+      const node2 = build(kids, void 0, span, rawKids, EMPTY_TL2, void 0);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, rawEntry(node2, input, pos, end));
+      }
+      EC.e = end;
+      return node2;
+    };
   }
-  function scopeRootPolicy(piece, flags) {
-    let out = piece;
+  function capturedFlatChildren(children2) {
+    if (children2.length === 0) return EMPTY_CH;
+    if (children2[0] !== void 0) return children2;
+    let first = 1;
+    while (first < children2.length && children2[first] === void 0) first++;
+    return first === children2.length ? EMPTY_CH : children2.slice(first);
+  }
+  function childrenOnlyBuildNode(child, build) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const kids = [];
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = kids;
+      ctx._cstLeaves = kids;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = void 0;
+      const value = child(input, pos, ctx);
+      const captured = capturedFlatChildren(kids);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const node2 = build(captured, void 0, { start: pos, end }, EMPTY_CH, EMPTY_TL2, void 0);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, sBuf !== void 0 || sRaw !== void 0 ? rawEntry(node2, input, pos, end) : void 0);
+      }
+      EC.e = end;
+      return node2;
+    };
+  }
+  function childrenOnlyFieldsBuildNode(child, build) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const kids = [];
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = kids;
+      ctx._cstLeaves = kids;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = [];
+      const value = child(input, pos, ctx);
+      const captured = capturedFlatChildren(kids);
+      const fieldMap = buildFieldMap(ctx._fields);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const node2 = build(captured, fieldMap, { start: pos, end }, EMPTY_CH, EMPTY_TL2, void 0);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, sBuf !== void 0 || sRaw !== void 0 ? rawEntry(node2, input, pos, end) : void 0);
+      }
+      EC.e = end;
+      return node2;
+    };
+  }
+  function collapseBuildNode(child, build) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const buf = {};
+      ctx._cstBuf = buf;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = void 0;
+      const value = child(input, pos, ctx);
+      const kids = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY_CH);
+      const rawKids = buf.raw ?? (buf.rawSingle !== void 0 ? [buf.rawSingle] : EMPTY_CH);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const span = { start: pos, end };
+      const node2 = kids.length === 1 ? kids[0] : build(kids, void 0, span, rawKids, EMPTY_TL2, void 0);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, rawEntry(node2, input, pos, end));
+      }
+      EC.e = end;
+      return node2;
+    };
+  }
+  function childrenOnlyCollapseBuildNode(child, build) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const kids = [];
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = kids;
+      ctx._cstLeaves = kids;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = void 0;
+      const value = child(input, pos, ctx);
+      const captured = capturedFlatChildren(kids);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const node2 = captured.length === 1 ? captured[0] : build(captured, void 0, { start: pos, end }, EMPTY_CH, EMPTY_TL2, void 0);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, sBuf !== void 0 || sRaw !== void 0 ? rawEntry(node2, input, pos, end) : void 0);
+      }
+      EC.e = end;
+      return node2;
+    };
+  }
+  function plainProjectNode(child, projection, type) {
+    return (input, pos, ctx) => {
+      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 savedFields = ctx._fields;
+      const buf = {};
+      ctx._cstBuf = buf;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx.captureTrivia = false;
+      ctx._fields = void 0;
+      const value = child(input, pos, ctx);
+      const kids = buf.ch ?? (buf.single !== void 0 ? [buf.single] : EMPTY_CH);
+      ctx._fields = savedFields;
+      ctx._cstBuf = sBuf;
+      ctx._cstChildren = sCh;
+      ctx._cstLeaves = sLv;
+      ctx._cstRawChildren = sRaw;
+      ctx._cstTriviaLog = sTl;
+      ctx.captureTrivia = sCap;
+      if (value === FAIL) return FAIL;
+      const end = EC.e;
+      const node2 = projectChild(kids, projection, type);
+      if (sBuf !== void 0 || sCh !== void 0) {
+        pushCstChild(ctx, node2, rawEntry(node2, input, pos, end));
+      }
+      EC.e = end;
+      return node2;
+    };
+  }
+  function rollbackNeeded(ctx) {
+    return ctx._cstBuf !== void 0 || ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0;
+  }
+  let MRAW = 0;
+  let MTL = 0;
+  let MLV = 0;
+  function markCst(ctx) {
+    const b = ctx._cstBuf;
+    if (b !== void 0) {
+      const raw = b.raw;
+      MRAW = 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;
+      MTL = tl !== void 0 ? tl.length : 0;
+      return true;
+    }
+    if (ctx._cstLeaves !== void 0 || ctx._cstRawChildren !== void 0 || ctx._cstTriviaLog !== void 0 || ctx._fields !== void 0 || ctx._errors !== void 0 || ctx._triviaLog !== void 0 || ctx._rootTriviaLog !== void 0) {
+      MRAW = ctx._cstRawChildren?.length ?? 0;
+      MTL = ctx._cstTriviaLog?.length ?? 0;
+      MLV = ctx._cstLeaves?.length ?? 0;
+      return true;
+    }
+    MRAW = 0;
+    MTL = 0;
+    MLV = 0;
+    return false;
+  }
+  function scopeRootPolicy(piece, flags) {
+    let out = piece;
     if ((flags & 1) !== 0) {
       const inner = out;
       out = (input, pos, ctx) => {
@@ -8490,9 +10243,7 @@ function assemble(t2, prog, cfg) {
     }
     if (s !== null) return skipTriviaScanned(s, input, cur, ctx);
     if (needsDeferredTriviaCommit(ctx)) {
-      const scan = scanTrivia(input, cur, ctx);
-      scan.commit();
-      return scan.end;
+      return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
     }
     return advanceTrivia(input, cur, ctx);
   }
@@ -8530,7 +10281,7 @@ function assemble(t2, prog, cfg) {
     if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
-  function committed2(c) {
+  function committed3(c) {
     return c._fc === true;
   }
   function accSet(ax, acc) {
@@ -8539,6 +10290,207 @@ function assemble(t2, prog, cfg) {
     for (const s of ax) acc.push(s);
     return acc;
   }
+  const NEVER_PIECE = () => FAIL;
+  const NEVER_CLASS = { ascii: new Uint8Array(128), hi: [] };
+  const EMPTY_EXPECTED_PREFIX = (_target, _prev, acc) => acc;
+  function expectedBlock(start, e0, e1, e2, e3, prior) {
+    return (target, prev, acc) => {
+      if (prev < start) {
+        acc = prior(start, prev, acc);
+        prev = start;
+      }
+      if (target > start && prev < start + 1) acc = accSet(e0, acc);
+      if (target > start + 1 && prev < start + 2) acc = accSet(e1, acc);
+      if (target > start + 2 && prev < start + 3) acc = accSet(e2, acc);
+      if (target > start + 3 && prev < start + 4) acc = accSet(e3, acc);
+      return acc;
+    };
+  }
+  function maskedChoiceBlock(start, a0, a1, a2, a3, through, next, total, choiceFx) {
+    return (input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+      if ((bits & 1 << start) !== 0) {
+        ctx._fc = false;
+        const v = a0(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start, prev, acc);
+        prev = start + 1;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if ((bits & 1 << start + 1) !== 0) {
+        ctx._fc = false;
+        const v = a1(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 1, prev, acc);
+        prev = start + 2;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if ((bits & 1 << start + 2) !== 0) {
+        ctx._fc = false;
+        const v = a2(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 2, prev, acc);
+        prev = start + 3;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if ((bits & 1 << start + 3) !== 0) {
+        ctx._fc = false;
+        const v = a3(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 3, prev, acc);
+        prev = start + 4;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if (next !== void 0) {
+        return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev);
+      }
+      acc = through(total, prev, acc);
+      ctx._fe = pos;
+      ctx._fx = acc ?? choiceFx;
+      return FAIL;
+    };
+  }
+  function generalChoiceBlock(start, a0, a1, a2, a3, g0, g1, g2, g3, through, next, total, choiceFx) {
+    return (input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev) => {
+      if (g0 === null || classHas2(g0, c)) {
+        ctx._fc = false;
+        const v = a0(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start, prev, acc);
+        prev = start + 1;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if (g1 === null || classHas2(g1, c)) {
+        ctx._fc = false;
+        const v = a1(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 1, prev, acc);
+        prev = start + 2;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if (g2 === null || classHas2(g2, c)) {
+        ctx._fc = false;
+        const v = a2(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 2, prev, acc);
+        prev = start + 3;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if (g3 === null || classHas2(g3, c)) {
+        ctx._fc = false;
+        const v = a3(input, pos, ctx);
+        if (v !== FAIL) return v;
+        acc = through(start + 3, prev, acc);
+        prev = start + 4;
+        acc = accSet(ctx._fx, acc);
+        if (committed3(ctx)) {
+          if (acc !== void 0) ctx._fx = acc;
+          return FAIL;
+        }
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      }
+      if (next !== void 0) {
+        return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev);
+      }
+      acc = through(total, prev, acc);
+      ctx._fe = pos;
+      ctx._fx = acc ?? choiceFx;
+      return FAIL;
+    };
+  }
+  function exclusiveChoiceBlock(start, a0, a1, a2, a3, next) {
+    return (arm, input, pos, ctx) => {
+      if (arm === start) return a0(input, pos, ctx);
+      if (arm === start + 1) return a1(input, pos, ctx);
+      if (arm === start + 2) return a2(input, pos, ctx);
+      if (arm === start + 3) return a3(input, pos, ctx);
+      return next === void 0 ? FAIL : next(arm, input, pos, ctx);
+    };
+  }
+  function dispatchMatcherBlock(m0, a0, m1, a1, m2, a2, m3, a3, next) {
+    return (key) => {
+      if (m0(key)) return a0;
+      if (m1(key)) return a1;
+      if (m2(key)) return a2;
+      if (m3(key)) return a3;
+      return next?.(key);
+    };
+  }
+  function dispatchBranch(child, usesRouted) {
+    if (!usesRouted) {
+      return (input, _pos, selEnd, key, _selectorMark, ctx) => {
+        const mark = saveTriviaMark(ctx);
+        const v = child(input, selEnd, ctx);
+        if (v === FAIL) {
+          rollbackTrivia(ctx, mark);
+          ctx._fc = true;
+          return FAIL;
+        }
+        return [key, v];
+      };
+    }
+    return (input, pos, selEnd, key, selectorMark, ctx) => {
+      const savedRouted = ctx._routed;
+      rollbackTrivia(ctx, selectorMark);
+      const mark = saveTriviaMark(ctx);
+      ctx._routed = { value: key, span: { start: pos, end: selEnd } };
+      let v;
+      try {
+        v = child(input, pos, ctx);
+      } finally {
+        ctx._routed = savedRouted;
+      }
+      if (v === FAIL) {
+        rollbackTrivia(ctx, mark);
+        ctx._fc = true;
+        return FAIL;
+      }
+      return [key, v];
+    };
+  }
+  function dispatchArmBlock(start, a0, a1, a2, a3, next) {
+    return (arm, input, pos, selEnd, key, selectorMark, ctx) => {
+      if (arm === start) return a0(input, pos, selEnd, key, selectorMark, ctx);
+      if (arm === start + 1) return a1(input, pos, selEnd, key, selectorMark, ctx);
+      if (arm === start + 2) return a2(input, pos, selEnd, key, selectorMark, ctx);
+      if (arm === start + 3) return a3(input, pos, selEnd, key, selectorMark, ctx);
+      return next === void 0 ? FAIL : next(arm, input, pos, selEnd, key, selectorMark, ctx);
+    };
+  }
   function trackLinesInto(ctx, input, end) {
     const from = ctx._lineScannedTo ?? 0;
     if (end <= from) return;
@@ -8574,6 +10526,21 @@ function assemble(t2, prog, cfg) {
         const s = k[code[ip + 1]];
         const len = s.length;
         const xf = fx[code[ip + 2]];
+        const shared = rawScalarSpecs.has(code[ip + 1]) ? scalarFor(ip) : void 0;
+        if (shared !== void 0) {
+          return (input, pos, ctx) => {
+            const e = shared(input, pos);
+            if (e >= 0) {
+              if (cstCaptureActive(ctx)) pushLeaf(ctx, s, pos, e);
+              EC.e = e;
+              return s;
+            }
+            ctx._fe = pos;
+            ctx._fx = xf;
+            if (ctx._probe !== void 0) failAt(ctx, xf, pos);
+            return FAIL;
+          };
+        }
         if (len === 1) {
           const c0 = s.charCodeAt(0);
           return (input, pos, ctx) => {
@@ -8701,6 +10668,22 @@ function assemble(t2, prog, cfg) {
       case OP_RX: {
         const re = k[code[ip + 1]];
         const xf = fx[code[ip + 2]];
+        const shared = rawScalarSpecs.has(code[ip + 1]) ? scalarFor(ip) : void 0;
+        if (shared !== void 0) {
+          return (input, pos, ctx) => {
+            const e = shared(input, pos);
+            if (e >= 0) {
+              const v = input.slice(pos, e);
+              if (cstCaptureActive(ctx)) pushLeaf(ctx, v, pos, e);
+              EC.e = e;
+              return v;
+            }
+            ctx._fe = pos;
+            ctx._fx = xf;
+            if (ctx._probe !== void 0) failAt(ctx, xf, pos);
+            return FAIL;
+          };
+        }
         return (input, pos, ctx) => {
           re.lastIndex = pos;
           if (re.test(input)) {
@@ -8810,7 +10793,7 @@ function assemble(t2, prog, cfg) {
         const child = link(code[ip + 2]);
         if (cfg.tolerant || cfg.probe) return child;
         return (input, pos, ctx) => {
-          if (!classHas(cls, lead(input, pos))) {
+          if (!classHas2(cls, lead(input, pos))) {
             ctx._fe = pos;
             ctx._fx = xf;
             return FAIL;
@@ -9009,13 +10992,28 @@ function assemble(t2, prog, cfg) {
           const v = child(input, pos, ctx);
           if (v !== FAIL) return v;
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-          if (committed2(ctx)) return FAIL;
+          if (committed3(ctx)) return FAIL;
           ctx._fe = pos;
           return FAIL;
         };
       }
       /* ── zero-width ──────────────────────────────────────────────────────── */
       case OP_NOT: {
+        const scalarChild = scalarTerminalNotChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = scalarFor(scalarChild);
+          const xf2 = fx[code[ip + 2]];
+          return (input, pos, ctx) => {
+            if (recognize(input, pos) < 0) {
+              EC.e = pos;
+              return null;
+            }
+            ctx._fe = pos;
+            ctx._fx = xf2;
+            EC.e = pos;
+            return FAIL;
+          };
+        }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         return (input, pos, ctx) => {
@@ -9075,7 +11073,7 @@ function assemble(t2, prog, cfg) {
           ctx._fc = false;
           const v = child(input, pos, ctx);
           if (v === FAIL) {
-            if (committed2(ctx)) return FAIL;
+            if (committed3(ctx)) return FAIL;
             if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
             EC.e = pos;
             return null;
@@ -9126,6 +11124,92 @@ function assemble(t2, prog, cfg) {
           return value;
         };
       }
+      case OP_LEX_BODY: {
+        const recognize = t2.lex[code[ip + 1]];
+        const expected = fx[code[ip + 2]];
+        return (input, pos, ctx) => {
+          const recognized = recognize(input, pos);
+          if (recognized < 0) {
+            ctx._fe = pos;
+            ctx._fx = expected;
+            if (ctx._probe !== void 0) failAt(ctx, expected, pos);
+            return FAIL;
+          }
+          const lineFlags = code[ip + 4];
+          const hasSuffix = (lineFlags & 4) !== 0;
+          const suffixMatched = hasSuffix && recognized % 2 === 1;
+          const end = (recognized - (suffixMatched ? 1 : 0)) / 2;
+          if ((lineFlags & 1) !== 0) {
+            trackLinesInto(ctx, input, suffixMatched ? end - 1 : end);
+          }
+          if (hasSuffix) ctx._fc = false;
+          if (hasSuffix && suffixMatched && (lineFlags & 2) !== 0) {
+            trackLinesInto(ctx, input, end);
+          }
+          if (hasSuffix && !suffixMatched) {
+            const suffixExpected = fx[code[ip + 3]];
+            ctx._fe = end;
+            ctx._fx = suffixExpected;
+            if (ctx._probe !== void 0) failAt(ctx, suffixExpected, end);
+          }
+          const value = input.slice(pos, end);
+          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: { start: pos, end } });
+          EC.e = end;
+          return value;
+        };
+      }
+      case OP_LEX_PROGRAM: {
+        const run = t2.lexPrograms[code[ip + 1]];
+        const scanId = run.scan;
+        if (scanId !== void 0) {
+          return (input, pos, ctx) => {
+            const sTrivia = ctx.trivia, sKinds = ctx.triviaKindLabels;
+            const sBuf = ctx._cstBuf, sChildren = ctx._cstChildren, sLeaves = ctx._cstLeaves;
+            const sRaw = ctx._cstRawChildren, sTl = ctx._cstTriviaLog;
+            const sOuterTl = ctx._triviaLog, sRootTl = ctx._rootTriviaLog;
+            const wasCapturing = cstCaptureActive(ctx);
+            const sScan = SCAN;
+            SCAN = null;
+            ctx.trivia = void 0;
+            ctx.triviaKindLabels = void 0;
+            ctx._cstBuf = void 0;
+            ctx._cstChildren = void 0;
+            ctx._cstLeaves = void 0;
+            ctx._cstRawChildren = void 0;
+            ctx._cstTriviaLog = void 0;
+            ctx._triviaLog = void 0;
+            ctx._rootTriviaLog = void 0;
+            let end;
+            try {
+              end = run(input, pos, ctx, scans[scanId]);
+            } finally {
+              SCAN = sScan;
+              ctx.trivia = sTrivia;
+              ctx.triviaKindLabels = sKinds;
+              ctx._cstBuf = sBuf;
+              ctx._cstChildren = sChildren;
+              ctx._cstLeaves = sLeaves;
+              ctx._cstRawChildren = sRaw;
+              ctx._cstTriviaLog = sTl;
+              ctx._triviaLog = sOuterTl;
+              ctx._rootTriviaLog = sRootTl;
+            }
+            if (end < 0) return FAIL;
+            const value = input.slice(pos, end);
+            if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span: { start: pos, end } });
+            EC.e = end;
+            return value;
+          };
+        }
+        return (input, pos, ctx) => {
+          const end = run(input, pos, ctx);
+          if (end < 0) return FAIL;
+          const value = input.slice(pos, end);
+          if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: { start: pos, end } });
+          EC.e = end;
+          return value;
+        };
+      }
       case OP_LEAF: {
         const fn = fns[code[ip + 1]];
         const child = link(code[ip + 2]);
@@ -9166,38 +11250,73 @@ function assemble(t2, prog, cfg) {
         const fused = op === OP_SEQX;
         const base = fused ? ip + 3 : ip + 2;
         const n = code[fused ? ip + 2 : ip + 1];
-        const kids = new Array(n);
-        for (let i = 0; i < n; i++) kids[i] = link(code[base + i]);
         const wantValues = op !== OP_SEQV;
-        const fn = fused ? fns[code[ip + 1]] : void 0;
-        const runTerms = (input, pos, ctx, values) => {
-          const v0 = kids[0](input, pos, ctx);
-          if (v0 === FAIL) return -1;
-          if (values !== void 0) values.push(v0);
-          let cur = EC.e;
-          for (let i = 1; i < n; i++) {
-            cur = nextTerm(kids[i], input, cur, ctx);
+        const reducer = fused ? code[ip + 1] : -1;
+        const projection = reducer < 0 ? ~reducer : -1;
+        const fn = fused && projection < 0 ? fns[reducer] : void 0;
+        const runnerBlock = (count, r0, r1, r2, r3, next) => {
+          if (count === 1) return (input, cur, ctx, values, inherited) => {
+            cur = r0(input, cur, ctx, inherited);
             if (cur < 0) return -1;
             if (values !== void 0) values.push(TERMV);
-          }
-          return cur;
+            return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
+          };
+          if (count === 2) return (input, cur, ctx, values, inherited) => {
+            cur = r0(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r1(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
+          };
+          if (count === 3) return (input, cur, ctx, values, inherited) => {
+            cur = r0(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r1(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r2(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
+          };
+          return (input, cur, ctx, values, inherited) => {
+            cur = r0(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r1(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r2(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = r3(input, cur, ctx, inherited);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
+          };
         };
         if (REC) {
-          const syncs = new Array(n);
-          for (let i = 0; i < n; i++) syncs[i] = sentinelFor(code[base + n + i]);
-          const runners = new Array(n);
-          for (let i = 1; i < n; i++) {
+          const first2 = link(code[base]);
+          const firstSync = sentinelFor(code[base + n]);
+          const runnerAt = (i) => {
+            const sync = sentinelFor(code[base + n + i]);
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
-              const kid = kids[i];
-              runners[i] = (input, cur, ctx) => nextTerm(kid, input, cur, ctx);
-              continue;
+              const kid = link(kidIp);
+              return (input, cur, ctx, inherited) => {
+                ctx._sync = sync ?? inherited;
+                return nextTerm(kid, input, cur, ctx);
+              };
             }
             const negated = code[kidIp + 1] === 1;
             const ki = code[kidIp + 2];
             const kinds = ki < 0 ? void 0 : k[ki];
             const xf = fx[code[kidIp + 3]];
-            runners[i] = (input, cur, ctx) => {
+            return (input, cur, ctx, inherited) => {
+              ctx._sync = sync ?? inherited;
               if (!adjacencyHolds(input, cur, ctx, negated, kinds)) {
                 ctx._fe = cur;
                 ctx._fx = xf;
@@ -9206,25 +11325,34 @@ function assemble(t2, prog, cfg) {
               TERMV = null;
               return cur;
             };
-          }
+          };
+          const bindRunners = (start) => {
+            const count = Math.min(4, n - start);
+            const at = (offset) => runnerAt(start + offset);
+            const never = () => -1;
+            return runnerBlock(
+              count,
+              at(0),
+              count > 1 ? at(1) : never,
+              count > 2 ? at(2) : never,
+              count > 3 ? at(3) : never,
+              start + count < n ? bindRunners(start + count) : void 0
+            );
+          };
+          const tail2 = n > 1 ? bindRunners(1) : void 0;
           const runSyncTerms = (input, pos, ctx, values) => {
             const inherited = ctx._sync;
-            ctx._sync = syncs[0] ?? inherited;
-            const v0 = kids[0](input, pos, ctx);
+            ctx._sync = firstSync ?? inherited;
+            const v0 = first2(input, pos, ctx);
             if (v0 === FAIL) {
               ctx._sync = inherited;
               return -1;
             }
             if (values !== void 0) values.push(v0);
-            let cur = EC.e;
-            for (let i = 1; i < n; i++) {
-              ctx._sync = syncs[i] ?? inherited;
-              cur = runners[i](input, cur, ctx);
-              if (cur < 0) {
-                ctx._sync = inherited;
-                return -1;
-              }
-              if (values !== void 0) values.push(TERMV);
+            const cur = tail2 === void 0 ? EC.e : tail2(input, EC.e, ctx, values, inherited);
+            if (cur < 0) {
+              ctx._sync = inherited;
+              return -1;
             }
             ctx._sync = inherited;
             return cur;
@@ -9235,7 +11363,7 @@ function assemble(t2, prog, cfg) {
               const cur = runSyncTerms(input, pos, ctx, values);
               if (cur < 0) return FAIL;
               EC.e = cur;
-              return fn(values, { start: pos, end: cur });
+              return projection >= 0 ? values[projection] : fn(values, { start: pos, end: cur });
             };
           }
           if (wantValues) {
@@ -9260,19 +11388,18 @@ function assemble(t2, prog, cfg) {
           break;
         }
         if (hasAdj) {
-          const runners = new Array(n);
-          for (let i = 1; i < n; i++) {
+          const first2 = link(code[base]);
+          const runnerAt = (i) => {
             const kidIp = code[base + i];
             if (code[kidIp] !== OP_ADJ) {
-              const kid = kids[i];
-              runners[i] = (input, cur, ctx) => nextTerm(kid, input, cur, ctx);
-              continue;
+              const kid = link(kidIp);
+              return (input, cur, ctx) => nextTerm(kid, input, cur, ctx);
             }
             const negated = code[kidIp + 1] === 1;
             const ki = code[kidIp + 2];
             const kinds = ki < 0 ? void 0 : k[ki];
             const xf = fx[code[kidIp + 3]];
-            runners[i] = (input, cur, ctx) => {
+            return (input, cur, ctx) => {
               if (!adjacencyHolds(input, cur, ctx, negated, kinds)) {
                 ctx._fe = cur;
                 ctx._fx = xf;
@@ -9281,18 +11408,26 @@ function assemble(t2, prog, cfg) {
               TERMV = null;
               return cur;
             };
-          }
+          };
+          const bindRunners = (start) => {
+            const count = Math.min(4, n - start);
+            const at = (offset) => runnerAt(start + offset);
+            const never = () => -1;
+            return runnerBlock(
+              count,
+              at(0),
+              count > 1 ? at(1) : never,
+              count > 2 ? at(2) : never,
+              count > 3 ? at(3) : never,
+              start + count < n ? bindRunners(start + count) : void 0
+            );
+          };
+          const tail2 = bindRunners(1);
           const runAdjTerms = (input, pos, ctx, values) => {
-            const v0 = kids[0](input, pos, ctx);
+            const v0 = first2(input, pos, ctx);
             if (v0 === FAIL) return -1;
             if (values !== void 0) values.push(v0);
-            let cur = EC.e;
-            for (let i = 1; i < n; i++) {
-              cur = runners[i](input, cur, ctx);
-              if (cur < 0) return -1;
-              if (values !== void 0) values.push(TERMV);
-            }
-            return cur;
+            return tail2(input, EC.e, ctx, values);
           };
           if (fused) {
             return (input, pos, ctx) => {
@@ -9300,7 +11435,7 @@ function assemble(t2, prog, cfg) {
               const cur = runAdjTerms(input, pos, ctx, values);
               if (cur < 0) return FAIL;
               EC.e = cur;
-              return fn(values, { start: pos, end: cur });
+              return projection >= 0 ? values[projection] : fn(values, { start: pos, end: cur });
             };
           }
           if (wantValues) {
@@ -9320,12 +11455,12 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 1) {
-          const k0 = kids[0];
+          const k0 = link(code[base]);
           if (fused) {
             return (input, pos, ctx) => {
               const v = k0(input, pos, ctx);
               if (v === FAIL) return FAIL;
-              return fn([v], { start: pos, end: EC.e });
+              return projection === 0 ? v : fn([v], { start: pos, end: EC.e });
             };
           }
           if (wantValues) {
@@ -9342,7 +11477,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 2) {
-          const k0 = kids[0], k1 = kids[1];
+          const k0 = link(code[base]), k1 = link(code[base + 1]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -9350,7 +11485,7 @@ function assemble(t2, prog, cfg) {
               const cur = nextTerm(k1, input, EC.e, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
-              return fn([v0, TERMV], { start: pos, end: cur });
+              return projection === 0 ? v0 : projection === 1 ? TERMV : fn([v0, TERMV], { start: pos, end: cur });
             };
           }
           if (wantValues) {
@@ -9373,7 +11508,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 3) {
-          const k0 = kids[0], k1 = kids[1], k2 = kids[2];
+          const k0 = link(code[base]), k1 = link(code[base + 1]), k2 = link(code[base + 2]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -9384,7 +11519,7 @@ function assemble(t2, prog, cfg) {
               cur = nextTerm(k2, input, cur, ctx);
               if (cur < 0) return FAIL;
               EC.e = cur;
-              return fn([v0, v1, TERMV], { start: pos, end: cur });
+              return projection === 0 ? v0 : projection === 1 ? v1 : projection === 2 ? TERMV : fn([v0, v1, TERMV], { start: pos, end: cur });
             };
           }
           if (wantValues) {
@@ -9411,26 +11546,90 @@ function assemble(t2, prog, cfg) {
             return void 0;
           };
         }
+        const block = (count, k0, k1, k2, k3, next) => {
+          if (count === 1) return (input, cur, ctx, values) => {
+            cur = nextTerm(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);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(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);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(k1, input, cur, ctx);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(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);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(k1, input, cur, ctx);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(k2, input, cur, ctx);
+            if (cur < 0) return -1;
+            if (values !== void 0) values.push(TERMV);
+            cur = nextTerm(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);
+          };
+        };
+        const bind = (start) => {
+          const count = Math.min(4, n - start);
+          const child = (offset) => link(code[base + start + offset]);
+          return block(
+            count,
+            child(0),
+            count > 1 ? child(1) : NEVER_PIECE,
+            count > 2 ? child(2) : NEVER_PIECE,
+            count > 3 ? child(3) : NEVER_PIECE,
+            start + count < n ? bind(start + count) : void 0
+          );
+        };
+        const first = link(code[base]);
+        const tail = bind(1);
+        const runDirectTerms = (input, pos, ctx, values) => {
+          const v0 = first(input, pos, ctx);
+          if (v0 === FAIL) return -1;
+          if (values !== void 0) values.push(v0);
+          return tail(input, EC.e, ctx, values);
+        };
         if (fused) {
           return (input, pos, ctx) => {
             const values = [];
-            const cur = runTerms(input, pos, ctx, values);
+            const cur = runDirectTerms(input, pos, ctx, values);
             if (cur < 0) return FAIL;
             EC.e = cur;
-            return fn(values, { start: pos, end: cur });
+            return projection >= 0 ? values[projection] : fn(values, { start: pos, end: cur });
           };
         }
         if (wantValues) {
           return (input, pos, ctx) => {
             const values = [];
-            const cur = runTerms(input, pos, ctx, values);
+            const cur = runDirectTerms(input, pos, ctx, values);
             if (cur < 0) return FAIL;
             EC.e = cur;
             return values;
           };
         }
         return (input, pos, ctx) => {
-          const cur = runTerms(input, pos, ctx, void 0);
+          const cur = runDirectTerms(input, pos, ctx, void 0);
           if (cur < 0) return FAIL;
           EC.e = cur;
           return void 0;
@@ -9442,13 +11641,86 @@ function assemble(t2, prog, cfg) {
         const n = code[ip + 2];
         const choiceFx = fx[code[ip + 3]];
         const base = ip + 4;
-        const arms = new Array(n);
-        for (let i = 0; i < n; i++) arms[i] = link(code[base + i]);
-        const armFx = new Array(n);
-        for (let i = 0; i < n; i++) armFx[i] = fx[code[base + n + i]];
         if (table.exclusive) {
           const ascii = table.ascii;
           const hi = table.hi;
+          if (n === 2) {
+            const a0 = link(code[base]), a1 = link(code[base + 1]);
+            return (input, pos, ctx) => {
+              const c = lead(input, pos);
+              let arm = -1;
+              if (c >= 0 && c < 128) {
+                const a = ascii[c];
+                if (a !== 0) arm = a - 1;
+              } else if (c >= 128) {
+                for (let i = 0; i < hi.length; i += 3) {
+                  if (c >= hi[i] && c <= hi[i + 1]) {
+                    arm = hi[i + 2];
+                    break;
+                  }
+                }
+              }
+              if (arm >= 0) {
+                ctx._fc = false;
+                const v = arm === 0 ? a0(input, pos, ctx) : a1(input, pos, ctx);
+                if (v !== FAIL) return v;
+                if (committed3(ctx)) return FAIL;
+                const failed = ctx._fx;
+                if (failed !== void 0 && failed.length > 0) {
+                  ctx._fe = pos;
+                  return FAIL;
+                }
+              }
+              ctx._fe = pos;
+              ctx._fx = choiceFx;
+              return FAIL;
+            };
+          }
+          if (n === 3) {
+            const a0 = link(code[base]), a1 = link(code[base + 1]), a2 = link(code[base + 2]);
+            return (input, pos, ctx) => {
+              const c = lead(input, pos);
+              let arm = -1;
+              if (c >= 0 && c < 128) {
+                const a = ascii[c];
+                if (a !== 0) arm = a - 1;
+              } else if (c >= 128) {
+                for (let i = 0; i < hi.length; i += 3) {
+                  if (c >= hi[i] && c <= hi[i + 1]) {
+                    arm = hi[i + 2];
+                    break;
+                  }
+                }
+              }
+              if (arm >= 0) {
+                ctx._fc = false;
+                const v = arm === 0 ? a0(input, pos, ctx) : arm === 1 ? a1(input, pos, ctx) : a2(input, pos, ctx);
+                if (v !== FAIL) return v;
+                if (committed3(ctx)) return FAIL;
+                const failed = ctx._fx;
+                if (failed !== void 0 && failed.length > 0) {
+                  ctx._fe = pos;
+                  return FAIL;
+                }
+              }
+              ctx._fe = pos;
+              ctx._fx = choiceFx;
+              return FAIL;
+            };
+          }
+          const bindExclusive = (start) => {
+            const at = (i) => i < n ? link(code[base + i]) : NEVER_PIECE;
+            const next = start + 4 < n ? bindExclusive(start + 4) : void 0;
+            return exclusiveChoiceBlock(
+              start,
+              at(start),
+              at(start + 1),
+              at(start + 2),
+              at(start + 3),
+              next
+            );
+          };
+          const selected = bindExclusive(0);
           return (input, pos, ctx) => {
             const c = lead(input, pos);
             let arm = -1;
@@ -9465,11 +11737,11 @@ function assemble(t2, prog, cfg) {
             }
             if (arm >= 0) {
               ctx._fc = false;
-              const v = arms[arm](input, pos, ctx);
+              const v = selected(arm, input, pos, ctx);
               if (v !== FAIL) return v;
-              if (committed2(ctx)) return FAIL;
-              const armFx2 = ctx._fx;
-              if (armFx2 !== void 0 && armFx2.length > 0) {
+              if (committed3(ctx)) return FAIL;
+              const armFx = ctx._fx;
+              if (armFx !== void 0 && armFx.length > 0) {
                 ctx._fe = pos;
                 return FAIL;
               }
@@ -9480,25 +11752,25 @@ function assemble(t2, prog, cfg) {
           };
         }
         const armCls = table.armCls;
-        const gates = new Array(n);
-        for (let i = 0; i < n; i++) gates[i] = armCls[i] ?? null;
-        const maskable = n <= 32;
-        let cand;
-        if (maskable) {
-          const m = new Uint32Array(129);
-          for (let i = 0; i < n; i++) {
-            const cls = gates[i];
-            const bit = 1 << i;
+        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 e0 = fx[code[base + n]];
+          const e1 = fx[code[base + n + 1]];
+          const e2 = n === 3 ? fx[code[base + n + 2]] : void 0;
+          const g0 = armCls[0] ?? null, g1 = armCls[1] ?? null;
+          const g2 = n === 3 ? armCls[2] ?? null : null;
+          const mask = new Uint32Array(129);
+          const addGate = (cls, bit) => {
             if (cls === null) {
-              for (let c = 0; c < 129; c++) m[c] |= bit;
-              continue;
+              for (let c = 0; c < 129; c++) mask[c] |= bit;
+              return;
             }
-            for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) m[c] |= bit;
-          }
-          cand = m;
-        }
-        if (cand !== void 0) {
-          const mask = cand;
+            for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) mask[c] |= bit;
+          };
+          addGate(g0, 1);
+          addGate(g1, 2);
+          if (n === 3) addGate(g2, 4);
           return (input, pos, ctx) => {
             const c = lead(input, pos);
             const need = markCst(ctx);
@@ -9511,50 +11783,206 @@ function assemble(t2, prog, cfg) {
             const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let acc;
             if (c < 128) {
-              const bits0 = mask[c < 0 ? 128 : c];
-              let bits = bits0;
+              const bits = mask[c < 0 ? 128 : c];
               let prev = 0;
-              while (bits !== 0) {
-                const i = 31 - Math.clz32(bits & -bits);
-                bits &= bits - 1;
+              if ((bits & 1) !== 0) {
+                ctx._fc = false;
+                const v = a0(input, pos, ctx);
+                if (v !== FAIL) return v;
+                prev = 1;
+                acc = accSet(ctx._fx, acc);
+                if (committed3(ctx)) {
+                  if (acc !== void 0) ctx._fx = acc;
+                  return FAIL;
+                }
+                if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              }
+              if ((bits & 2) !== 0) {
+                ctx._fc = false;
+                const v = a1(input, pos, ctx);
+                if (v !== FAIL) return v;
+                if (prev < 1) acc = accSet(e0, acc);
+                prev = 2;
+                acc = accSet(ctx._fx, acc);
+                if (committed3(ctx)) {
+                  if (acc !== void 0) ctx._fx = acc;
+                  return FAIL;
+                }
+                if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              }
+              if (n === 3 && (bits & 4) !== 0) {
                 ctx._fc = false;
-                const v = arms[i](input, pos, ctx);
+                const v = a2(input, pos, ctx);
                 if (v !== FAIL) return v;
-                for (let j = prev; j < i; j++) if ((bits0 & 1 << j) === 0) acc = accSet(armFx[j], acc);
-                prev = i + 1;
+                if (prev < 1) acc = accSet(e0, acc);
+                if (prev < 2) acc = accSet(e1, acc);
+                prev = 3;
                 acc = accSet(ctx._fx, acc);
-                if (committed2(ctx)) {
+                if (committed3(ctx)) {
                   if (acc !== void 0) ctx._fx = acc;
                   return FAIL;
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               }
-              for (let j = prev; j < n; j++) if ((bits0 & 1 << j) === 0) acc = accSet(armFx[j], acc);
+              if (prev < 1) acc = accSet(e0, acc);
+              if (prev < 2) acc = accSet(e1, acc);
+              if (n === 3 && prev < 3) acc = accSet(e2, acc);
               ctx._fe = pos;
               ctx._fx = acc ?? choiceFx;
               return FAIL;
             }
-            for (let i = 0; i < n; i++) {
-              const cls = gates[i];
-              if (cls !== null && !classHas(cls, c)) {
-                acc = accSet(armFx[i], acc);
-                continue;
+            if (g0 === null || classHas2(g0, c)) {
+              ctx._fc = false;
+              const v = a0(input, pos, ctx);
+              if (v !== FAIL) return v;
+              acc = accSet(ctx._fx, acc);
+              if (committed3(ctx)) {
+                if (acc !== void 0) ctx._fx = acc;
+                return FAIL;
               }
+              if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+            } else acc = accSet(e0, acc);
+            if (g1 === null || classHas2(g1, c)) {
               ctx._fc = false;
-              const v = arms[i](input, pos, ctx);
+              const v = a1(input, pos, ctx);
               if (v !== FAIL) return v;
               acc = accSet(ctx._fx, acc);
-              if (committed2(ctx)) {
+              if (committed3(ctx)) {
                 if (acc !== void 0) ctx._fx = acc;
                 return FAIL;
               }
               if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+            } else acc = accSet(e1, acc);
+            if (n === 3) {
+              if (g2 === null || classHas2(g2, c)) {
+                ctx._fc = false;
+                const v = a2(input, pos, ctx);
+                if (v !== FAIL) return v;
+                acc = accSet(ctx._fx, acc);
+                if (committed3(ctx)) {
+                  if (acc !== void 0) ctx._fx = acc;
+                  return FAIL;
+                }
+                if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              } else acc = accSet(e2, acc);
             }
             ctx._fe = pos;
             ctx._fx = acc ?? choiceFx;
             return FAIL;
           };
         }
+        const bindGeneral = (start, prior) => {
+          const arm = (i) => i < n ? link(code[base + i]) : NEVER_PIECE;
+          const expected = (i) => i < n ? fx[code[base + n + i]] : EMPTY_FX2;
+          const gate = (i) => i < n ? armCls[i] ?? null : NEVER_CLASS;
+          const through = expectedBlock(
+            start,
+            expected(start),
+            expected(start + 1),
+            expected(start + 2),
+            expected(start + 3),
+            prior
+          );
+          const next = start + 4 < n ? bindGeneral(start + 4, through) : void 0;
+          return generalChoiceBlock(
+            start,
+            arm(start),
+            arm(start + 1),
+            arm(start + 2),
+            arm(start + 3),
+            gate(start),
+            gate(start + 1),
+            gate(start + 2),
+            gate(start + 3),
+            through,
+            next,
+            n,
+            choiceFx
+          );
+        };
+        const general = bindGeneral(0, EMPTY_EXPECTED_PREFIX);
+        if (n <= 32) {
+          const mask = new Uint32Array(129);
+          for (let i = 0; i < n; i++) {
+            const cls = armCls[i] ?? null;
+            const bit = 1 << i;
+            if (cls === null) {
+              for (let c = 0; c < 129; c++) mask[c] |= bit;
+              continue;
+            }
+            for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) mask[c] |= bit;
+          }
+          const bindMasked = (start, prior) => {
+            const arm = (i) => i < n ? link(code[base + i]) : NEVER_PIECE;
+            const expected = (i) => i < n ? fx[code[base + n + i]] : EMPTY_FX2;
+            const through = expectedBlock(
+              start,
+              expected(start),
+              expected(start + 1),
+              expected(start + 2),
+              expected(start + 3),
+              prior
+            );
+            const next = start + 4 < n ? bindMasked(start + 4, through) : void 0;
+            return maskedChoiceBlock(
+              start,
+              arm(start),
+              arm(start + 1),
+              arm(start + 2),
+              arm(start + 3),
+              through,
+              next,
+              n,
+              choiceFx
+            );
+          };
+          const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
+          return (input, pos, ctx) => {
+            const c = lead(input, pos);
+            const need = markCst(ctx);
+            const mRaw = MRAW;
+            const mTl = MTL;
+            const mLv = MLV;
+            const mFl = need ? ctx._fields?.length ?? 0 : 0;
+            const mEr = need ? ctx._errors?.length ?? 0 : 0;
+            const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+            const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
+            if (c < 128) {
+              return masked(
+                input,
+                pos,
+                ctx,
+                mask[c < 0 ? 128 : c],
+                need,
+                mRaw,
+                mTl,
+                mLv,
+                mFl,
+                mEr,
+                mLog,
+                mRoot,
+                void 0,
+                0
+              );
+            }
+            return general(
+              input,
+              pos,
+              ctx,
+              c,
+              need,
+              mRaw,
+              mTl,
+              mLv,
+              mFl,
+              mEr,
+              mLog,
+              mRoot,
+              void 0,
+              0
+            );
+          };
+        }
         return (input, pos, ctx) => {
           const c = lead(input, pos);
           const need = markCst(ctx);
@@ -9565,26 +11993,22 @@ function assemble(t2, prog, cfg) {
           const mEr = need ? ctx._errors?.length ?? 0 : 0;
           const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
           const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
-          let acc;
-          for (let i = 0; i < n; i++) {
-            const cls = gates[i];
-            if (cls !== null && !classHas(cls, c)) {
-              acc = accSet(armFx[i], acc);
-              continue;
-            }
-            ctx._fc = false;
-            const v = arms[i](input, pos, ctx);
-            if (v !== FAIL) return v;
-            acc = accSet(ctx._fx, acc);
-            if (committed2(ctx)) {
-              if (acc !== void 0) ctx._fx = acc;
-              return FAIL;
-            }
-            if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-          }
-          ctx._fe = pos;
-          ctx._fx = acc ?? choiceFx;
-          return FAIL;
+          return general(
+            input,
+            pos,
+            ctx,
+            c,
+            need,
+            mRaw,
+            mTl,
+            mLv,
+            mFl,
+            mEr,
+            mLog,
+            mRoot,
+            void 0,
+            0
+          );
         };
       }
       /* ── greedyClassify / autoNot ────────────────────────────────────────── */
@@ -9653,7 +12077,7 @@ function assemble(t2, prog, cfg) {
           if (nc !== 0) {
             const c = lead(input, end);
             for (let i = 0; i < nc; i++) {
-              if (!classHas(clss[i], c)) continue;
+              if (!classHas2(clss[i], c)) continue;
               ctx._fc = false;
               ctx._fx = void 0;
               return FAIL;
@@ -9677,6 +12101,9 @@ function assemble(t2, prog, cfg) {
         const reportItem = (flags & 4) !== 0;
         const itemFx = reportItem ? fx[code[ip + 6]] : EMPTY_FX2;
         const collect = op === OP_REP;
+        const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
+        const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
+        const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const skipBeforeFirst = sepIp < 0 && min === 0;
         if (REC) {
           const itemFx2 = fx[code[ip + 6]];
@@ -9710,7 +12137,7 @@ function assemble(t2, prog, cfg) {
                 const sv = sep(input, sp, ctx);
                 if (sv === FAIL) {
                   if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-                  if (committed2(ctx)) return FAIL;
+                  if (committed3(ctx)) return FAIL;
                   break;
                 }
                 if (!keepSeparators) demoteCapturedToRaw(ctx, leavesBefore);
@@ -9727,7 +12154,7 @@ function assemble(t2, prog, cfg) {
               ctx._fc = false;
               const v = child(input, itemStart, ctx);
               if (v === FAIL) {
-                if (committed2(ctx)) {
+                if (committed3(ctx)) {
                   if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
                   return FAIL;
                 }
@@ -9773,11 +12200,13 @@ function assemble(t2, prog, cfg) {
           const out = collect ? [] : void 0;
           const hasTrivia = ctx.trivia !== void 0;
           const needMark = rollbackNeeded(ctx);
+          const gateItems = itemMayStart !== void 0 && ctx._probe === void 0;
           let cur = pos;
           let count = 0;
           for (; ; ) {
             if (max >= 0 && count >= max) break;
             if (sep !== void 0 && count > 0 && count >= min && cur >= input.length) break;
+            if (count >= min && sep === void 0 && !hasTrivia && gateItems && !itemMayStart(input, cur)) break;
             if (needMark) markCst(ctx);
             const mRaw = needMark ? MRAW : 0;
             const mTl = needMark ? MTL : 0;
@@ -9797,7 +12226,7 @@ function assemble(t2, prog, cfg) {
               const sv = sep(input, sp, ctx);
               if (sv === FAIL) {
                 if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-                if (committed2(ctx)) return FAIL;
+                if (committed3(ctx)) return FAIL;
                 break;
               }
               if (!keepSeparators) demoteCapturedToRaw(ctx, leavesBefore);
@@ -9811,11 +12240,16 @@ function assemble(t2, prog, cfg) {
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
+            if (count >= min && gateItems && !itemMayStart(input, itemStart)) {
+              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
+              break;
+            }
             ctx._fc = false;
             const v = child(input, itemStart, ctx);
             if (v === FAIL) {
               if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
-              if (committed2(ctx)) return FAIL;
+              if (committed3(ctx)) return FAIL;
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
@@ -9847,78 +12281,103 @@ function assemble(t2, prog, cfg) {
         const otherRouted = code[ip + 4] === 1;
         const n = code[ip + 5];
         const armBase = ip + 6;
-        const arms = new Array(n);
-        for (let i = 0; i < n; i++) arms[i] = link(code[armBase + i]);
         const byKey = spec.byKey;
         const byFold = spec.byFold;
         const hasFold = spec.byFold.size > 0;
         const match = spec.match;
         const matchN = match.length;
-        const matchFn = new Array(matchN);
-        const matchArm = new Array(matchN);
-        for (let i = 0; i < matchN; i++) {
-          matchFn[i] = linkMatcher(match[i]);
-          matchArm[i] = match[i][3];
-        }
         const routed2 = spec.routed;
         const expected = spec.expected;
+        const validArm = (arm) => Number.isInteger(arm) && arm >= 0 && arm < n;
+        if (routed2.length !== n) throw new TypeError("table assembler: malformed dispatch routed arity");
+        for (const arm of byKey.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch exact arm");
+        for (const arm of byFold.values()) if (!validArm(arm)) throw new TypeError("table assembler: malformed dispatch folded arm");
+        for (const m of match) if (!validArm(m[3])) throw new TypeError("table assembler: malformed dispatch matcher arm");
+        const neverMatch = () => false;
+        const bindMatchers = (start) => {
+          const pred = (i) => i < matchN ? linkMatcher(match[i]) : neverMatch;
+          const arm = (i) => i < matchN ? match[i][3] : -1;
+          const next = start + 4 < matchN ? bindMatchers(start + 4) : void 0;
+          return dispatchMatcherBlock(
+            pred(start),
+            arm(start),
+            pred(start + 1),
+            arm(start + 1),
+            pred(start + 2),
+            arm(start + 2),
+            pred(start + 3),
+            arm(start + 3),
+            next
+          );
+        };
+        const matchBlock = matchN === 0 ? void 0 : bindMatchers(0);
+        const classify = hasFold ? matchBlock === void 0 ? (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) : (key) => byKey.get(key) ?? byFold.get(asciiFoldKey(key)) ?? matchBlock(key) : matchBlock === void 0 ? (key) => byKey.get(key) : (key) => byKey.get(key) ?? matchBlock(key);
+        const neverBranch = () => FAIL;
+        const bindArms = (start) => {
+          const branch = (i) => i < n ? dispatchBranch(link(code[armBase + i]), routed2[i] === 1) : neverBranch;
+          const next = start + 4 < n ? bindArms(start + 4) : void 0;
+          return dispatchArmBlock(
+            start,
+            branch(start),
+            branch(start + 1),
+            branch(start + 2),
+            branch(start + 3),
+            next
+          );
+        };
+        const runArm = n === 0 ? void 0 : bindArms(0);
+        const runOther = other === void 0 ? void 0 : dispatchBranch(other, otherRouted);
         return (input, pos, ctx) => {
           const selectorMark = saveTriviaMark(ctx);
           const selVal = selector(input, pos, ctx);
           if (selVal === FAIL) return FAIL;
           const selEnd = EC.e;
           const key = selVal;
-          let arm = byKey.get(key);
-          if (arm === void 0 && hasFold) arm = byFold.get(asciiFoldKey(key));
-          if (arm === void 0) {
-            for (let i = 0; i < matchN; i++) {
-              if (matchFn[i](key)) {
-                arm = matchArm[i];
-                break;
-              }
-            }
-          }
-          let target;
-          let usesRouted;
+          const arm = classify(key);
           if (arm === void 0) {
-            if (other === void 0) {
+            if (runOther === void 0) {
               ctx._fe = selEnd;
               ctx._fx = expected;
               return FAIL;
             }
-            target = other;
-            usesRouted = otherRouted;
-          } else {
-            target = arms[arm];
-            usesRouted = routed2[arm] === 1;
-          }
-          let mark = saveTriviaMark(ctx);
-          let v;
-          if (usesRouted) {
-            const savedRouted = ctx._routed;
-            rollbackTrivia(ctx, selectorMark);
-            mark = saveTriviaMark(ctx);
-            ctx._routed = { value: key, span: { start: pos, end: selEnd } };
-            try {
-              v = target(input, pos, ctx);
-            } finally {
-              ctx._routed = savedRouted;
-            }
-          } else {
-            v = target(input, selEnd, ctx);
-          }
-          if (v === FAIL) {
-            rollbackTrivia(ctx, mark);
-            ctx._fc = true;
-            return FAIL;
+            return runOther(input, pos, selEnd, key, selectorMark, ctx);
           }
-          return [key, v];
+          return runArm(arm, input, pos, selEnd, key, selectorMark, ctx);
         };
       }
       /* ── node ────────────────────────────────────────────────────────────── */
       case OP_NODE:
       case OP_NODE_TRACK: {
         const flags = code[ip + 3];
+        const scalarChild = !hostCst && !cfg.tolerant && !cfg.probe && !cfg.coverage && !cfg.trackLines ? scalarTerminalNodeChild(code, ip) : -1;
+        if (scalarChild >= 0) {
+          const recognize = scalarFor(scalarChild);
+          const spec = k[code[scalarChild + 1]];
+          const regexValue = code[scalarChild] === OP_RX;
+          const xf = fx[code[scalarChild + 2]];
+          const build2 = fns[code[ip + 1]];
+          return (input, pos, ctx) => {
+            const end = recognize(input, pos);
+            if (end < 0) {
+              ctx._fe = pos;
+              ctx._fx = xf;
+              if (ctx._probe !== void 0) failAt(ctx, xf, pos);
+              return FAIL;
+            }
+            const value = regexValue ? input.slice(pos, end) : spec;
+            const leaf2 = { _tag: "leaf", value, span: { start: pos, end } };
+            const kids = [leaf2];
+            const rawKids = [leaf2];
+            const span = { start: pos, end };
+            EC.e = end;
+            const nd = build2(kids, void 0, span, rawKids, EMPTY_TL2, void 0);
+            if (ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0) {
+              pushCstChild(ctx, nd, ctx._cstRawChildren !== void 0 || ctx._cstBuf !== void 0 ? rawEntry(nd, input, pos, end) : void 0);
+            }
+            EC.e = end;
+            return nd;
+          };
+        }
         const child = link(code[ip + 2]);
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
@@ -9933,6 +12392,26 @@ function assemble(t2, prog, cfg) {
         const unwrap = (flags & 64) !== 0;
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fns[buildIdx] : void 0;
+        if (!hostCst && !tracked) {
+          if (build !== void 0 && proj < 0 && flags === 0) {
+            return plainBuildNode(child, build);
+          }
+          if (build !== void 0 && proj < 0 && flags === 2) {
+            return childrenOnlyBuildNode(child, build);
+          }
+          if (build !== void 0 && proj < 0 && flags === 18) {
+            return childrenOnlyFieldsBuildNode(child, build);
+          }
+          if (build !== void 0 && proj < 0 && flags === 32) {
+            return collapseBuildNode(child, build);
+          }
+          if (build !== void 0 && proj < 0 && flags === 34) {
+            return childrenOnlyCollapseBuildNode(child, build);
+          }
+          if (build === void 0 && proj >= 0 && flags === 0) {
+            return plainProjectNode(child, proj, type);
+          }
+        }
         const structural = build === void 0 && proj < 0;
         const grammarCapture = (flags & 1) !== 0 || trailingTrivia;
         const hostCapturesThisType = structural && cfg.hostCaptureTrivia !== void 0 ? cfg.hostCaptureTrivia(type) : void 0;
@@ -10052,14 +12531,27 @@ function assemble(t2, prog, cfg) {
       if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
     }
     for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
-    const validationRoots = [...Object.values(prog.rules), ...extraIps];
-    for (const ip of reachableSites(code, validationRoots)) {
-      if (code[ip] !== OP_DISPATCH) continue;
-      validateDispatchSpec(dsp[code[ip + 2]], code[ip + 5], code[ip + 4]);
+    const roots = [...Object.values(prog.rules), ...extraIps];
+    for (const ip of reachableSites(code, roots)) {
+      if (code[ip] === OP_DISPATCH) {
+        const spec = dsp[code[ip + 2]];
+        validateDispatchSpec(spec, code[ip + 5], code[ip + 4]);
+      }
+      if (!hostCst && !cfg.tolerant && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+        if (code[ip] === OP_NODE) {
+          const child = scalarTerminalNodeChild(code, ip);
+          if (child >= 0) {
+            rawScalarSpecs.add(code[child + 1]);
+            scalarFor(child);
+          }
+        }
+      }
+      const notChild = scalarTerminalNotChild(code, ip);
+      if (notChild >= 0) scalarFor(notChild);
     }
     const pre = cfg.hostCaptureTrivia === void 0 ? prog.asm?.find((a) => a.key === cfgKey(cfg)) : void 0;
     if (pre !== void 0) {
-      const pools = rebuildPools(t2.cc, t2.fx, pre.plan);
+      const pools = rebuildPools(t2.cc, t2.fx, t2.disp, pre.plan);
       emitted = pre.factory(
         EC,
         FAIL,
@@ -10085,7 +12577,7 @@ function assemble(t2, prog, cfg) {
         rollbackTriviaAt,
         rollbackScannedTriviaAt,
         failAt,
-        classHas,
+        classHas2,
         consumeTrivia,
         buildFieldMap,
         projectChild,
@@ -10106,7 +12598,13 @@ function assemble(t2, prog, cfg) {
         matchesAt,
         recoverScan,
         orSentinel,
-        captureError
+        captureError,
+        scalarRecognizers,
+        commitTriviaScan,
+        scanTriviaCompact,
+        t2.lex,
+        adjacencyHolds,
+        t2.lexPrograms
       );
       emitReached = new Set(pre.reached);
     }
@@ -10156,7 +12654,7 @@ function assemble(t2, prog, cfg) {
         rollbackTriviaAt,
         rollbackScannedTriviaAt,
         failAt,
-        classHas,
+        classHas2,
         consumeTrivia,
         buildFieldMap,
         projectChild,
@@ -10182,7 +12680,13 @@ function assemble(t2, prog, cfg) {
         matchesAt,
         recoverScan,
         orSentinel,
-        captureError
+        captureError,
+        scalarRecognizers,
+        commitTriviaScan,
+        scanTriviaCompact,
+        t2.lex,
+        adjacencyHolds,
+        t2.lexPrograms
       );
       emitReached = em.reached;
     } catch (e) {
@@ -10485,6 +12989,8 @@ function programFields(prog, fns, opts = {}) {
     // `run({ rootTrivia })` rejected a grammar that plainly has labels — the
     // exact failure the root-trivia work exists to prevent, one hop downstream.
     ...prog.dsp.length === 0 ? [] : [`p:[${prog.dsp.map(emitDispatchSpec).join(",")}],`],
+    ...prog.lex === void 0 ? [] : [`lx:[${prog.lex.map((row) => `[${row.join(",")}]`).join(",")}],`],
+    ...prog.lexPrograms === void 0 ? [] : [`lp:[${prog.lexPrograms.map((row) => `[${row.join(",")}]`).join(",")}],`],
     ...prog.labels === void 0 ? [] : [`lb:[${prog.labels.map(jsString).join(",")}],`],
     ...prog.classified === 1 ? ["rc:1,"] : [],
     // Without this a recovery table's MODULE loads as a strict one: the extra
@@ -12288,7 +14794,11 @@ function not(combinator) {
       const result = combinator.parse(input, pos, ctx);
       rollbackLookahead(ctx, mark);
       if (result.ok) {
-        return { ok: false, expected: [`not(${combinator._tag})`], span: { start: pos, end: pos } };
+        return {
+          ok: false,
+          expected: assertionFailureExpected(false, combinator._tag),
+          span: { start: pos, end: pos }
+        };
       }
       return { ok: true, value: null, span: { start: pos, end: pos } };
     }