parseman 0.56.0 → 0.58.0

package/dist/cli/index.js

@@ -819,6 +819,31 @@ function pushCstChild(ctx, built, rawEntry2) {
   else if (ctx._cstLeaves) ctx._cstLeaves.push(built);
   if (ctx._cstRawChildren) ctx._cstRawChildren.push(rawEntry2);
 }
+function popCstChild(ctx) {
+  const b = ctx._cstBuf;
+  if (b) {
+    const ch2 = b.ch;
+    if (b.rawOnly !== true && ch2) {
+      ch2.pop();
+      if (ch2.length === 1) {
+        b.single = ch2[0];
+        b.ch = void 0;
+      }
+    }
+    if (b.noRaw === true) b.rawLen = (b.rawLen ?? 1) - 1;
+    else if (b.raw) {
+      b.raw.pop();
+      if (b.raw.length === 1) {
+        b.rawSingle = b.raw[0];
+        b.raw = void 0;
+      }
+    } else b.rawSingle = void 0;
+    return;
+  }
+  if (ctx._cstChildren) ctx._cstChildren.pop();
+  else if (ctx._cstLeaves) ctx._cstLeaves.pop();
+  if (ctx._cstRawChildren) ctx._cstRawChildren.pop();
+}
 function cstRawLen(ctx) {
   const b = ctx._cstBuf;
   if (b) {
@@ -977,6 +1002,7 @@ function literalCodePoints(frag) {
     if (ch2 === "\\") {
       const e = frag[i + 1];
       if (e === void 0) return null;
+      if (!(e in CLASS_ESCAPES) && /\w/.test(e)) return null;
       out.push(e in CLASS_ESCAPES ? CLASS_ESCAPES[e] : e.codePointAt(0));
       i += 2;
       continue;
@@ -1089,6 +1115,7 @@ function createParseContext() {
     _rootTriviaKindIndex: void 0,
     _rootTriviaStrictScopes: void 0,
     _rootTriviaCapture: void 0,
+    _gap: void 0,
     _cstTriviaLog: void 0,
     _fields: void 0,
     _cstBuf: void 0,
@@ -1571,7 +1598,10 @@ function labeledTriviaSpec(arms, minRepeats) {
     arms,
     minRepeats,
     visitor: commonLabeledTriviaVisitor({ arms, minRepeats }),
-    charArms: charArmsFor({ arms, minRepeats })
+    charArms: charArmsFor({ arms, minRepeats }),
+    rootKinds: void 0,
+    rootLeaders: [],
+    rootScan: null
   };
 }
 function matchArmAt(input, pos, arm, state) {
@@ -2031,8 +2061,50 @@ function loopScanner(arms) {
 function regexTriviaScanner(parser2) {
   const d = parser2._def.tag === "label" ? parser2._def.parser._def : parser2._def;
   if (d.tag !== "regex" || d.flags) return null;
-  const source = d.source;
-  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source);
+  return sourceScanner(d.source);
+}
+function sourceScanner(source) {
+  return classRunSource(source) ?? altStarSource(source) ?? prefixRunSource(source) ?? delimitedSource(source) ?? sharedPrefixAltSource(source);
+}
+function sharedPrefixAltSource(source) {
+  const m = /^((?:\\.|[^\\[\]()*+?|^$.{}])+)\(\?:(.*)\)$/.exec(source);
+  if (!m) return null;
+  const alts = [];
+  const body = m[2];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < body.length; i++) {
+    const c = body[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      while (i < body.length && body[i] !== "]") i += body[i] === "\\" ? 2 : 1;
+      continue;
+    }
+    if (c === "(") depth++;
+    else if (c === ")" && --depth < 0) return null;
+    else if (c === "|" && depth === 0) {
+      alts.push(body.slice(start, i));
+      start = i + 1;
+    }
+  }
+  if (depth !== 0 || alts.length === 0) return null;
+  alts.push(body.slice(start));
+  const scanners = [];
+  for (const alt of alts) {
+    const scanner = sourceScanner(m[1] + alt);
+    if (scanner === null) return null;
+    scanners.push(scanner);
+  }
+  return (input, cur) => {
+    for (const scanner of scanners) {
+      const end = scanner(input, cur);
+      if (end > cur) return end;
+    }
+    return cur;
+  };
 }
 function bmpString(cps) {
   if (!cps) return null;
@@ -2348,10 +2420,16 @@ function branchUsesRouted(branch) {
   return branch.usesRouted === true || parserUsesRouted(branch.parser);
 }
 function asciiFoldKey(key) {
-  let out = "";
-  for (let i = 0; i < key.length; i++) {
+  let i = 0;
+  for (; i < key.length; i++) {
+    const c = key.charCodeAt(i);
+    if (c >= 65 && c <= 90) break;
+  }
+  if (i === key.length) return key;
+  let out = key.slice(0, i);
+  for (; i < key.length; i++) {
     const c = key.charCodeAt(i);
-    out += String.fromCharCode(c >= 65 && c <= 90 ? c + 32 : c);
+    out += c >= 65 && c <= 90 ? String.fromCharCode(c + 32) : key[i];
   }
   return out;
 }
@@ -2680,6 +2758,42 @@ function keywords(words, opts = {}) {
   };
 }
 
+// src/combinators/trivia-boundary.ts
+var MAX_DEPTH = 12;
+function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
+  if (depth === 0) return true;
+  const d = p._def;
+  switch (d.tag) {
+    // Multi-term forms: the gaps BETWEEN terms are the ambient-trivia positions.
+    case "sequence":
+      return d.parsers.length > 1;
+    case "many":
+    case "oneOrMore":
+    case "sepBy":
+      return true;
+    // Transparent wrappers — they add no position, so ask what they wrap.
+    case "node":
+    case "transform":
+    case "leaf":
+    case "label":
+    case "field":
+    case "token":
+    case "attempt":
+    case "optional":
+    case "expect":
+    case "withCtx":
+    case "recover":
+    case "trivia":
+      return hasOwnTriviaBoundary(d.parser, depth - 1);
+    // An alternation adds no position either, but ONE arm that has one is enough
+    // to make the scope meaningful for this rule.
+    case "choice":
+      return d.parsers.some((a) => hasOwnTriviaBoundary(a, depth - 1));
+    default:
+      return false;
+  }
+}
+
 // src/compiler/token-alphabet.ts
 function optionalSuffixLexBody(ir) {
   if (ir.kind !== "sequence" || ir.parts.length !== 2) return void 0;
@@ -2699,7 +2813,10 @@ function selectOptionalSuffixLexBody(ir) {
   const token2 = { strategy: "token", estimatedOps: 2, body };
   return token2.estimatedOps < character.estimatedOps ? token2 : character;
 }
-function directTokenBodyParser(parser2, resolve2) {
+function reinstallsRuleTrivia(reference, target) {
+  return (reference._meta.grammarTrivia ?? target._meta.grammarTrivia) !== void 0 && hasOwnTriviaBoundary(target);
+}
+function directTokenBodyParser(parser2, resolve2, scope) {
   const outer = parser2._def;
   if (outer.tag !== "token") return void 0;
   let body = outer.parser;
@@ -2709,12 +2826,13 @@ function directTokenBodyParser(parser2, resolve2) {
     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;
+      if (scope !== void 0) scope.cleared = true;
       body = wrapper.parser;
       continue;
     }
     if (wrapper.tag === "lazy") {
       const target = resolvedLazyTarget(body, resolve2);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(body, target)) return void 0;
       body = target;
       continue;
     }
@@ -2886,7 +3004,7 @@ function directNot2TokenBody(parser2, resolve2) {
     terminal
   };
 }
-function directFixedLexNode(parser2, resolve2, active, pureOnly = false) {
+function directFixedLexNode(parser2, resolve2, active, pureOnly = false, cleared = false) {
   let current = parser2;
   const wrappers = /* @__PURE__ */ new Set();
   while (!wrappers.has(current)) {
@@ -2894,7 +3012,7 @@ function directFixedLexNode(parser2, resolve2, active, pureOnly = false) {
     const def = current._def;
     if (def.tag === "lazy") {
       const target = resolvedLazyTarget(current, resolve2);
-      if (target === void 0) return void 0;
+      if (target === void 0 || reinstallsRuleTrivia(current, target)) return void 0;
       current = target;
       continue;
     }
@@ -2912,30 +3030,33 @@ function directFixedLexNode(parser2, resolve2, active, pureOnly = false) {
     if (terminal !== void 0) return { kind: "terminal", terminal };
     const def = current._def;
     if (def.tag === "grammar") {
+      if (def.triviaParser === void 0 && def.captureTrivia !== true && def.rootCapture !== "opaque" && def.constructionCaptureTriviaKinds === void 0) {
+        return directFixedLexNode(def.parser, resolve2, active, pureOnly, cleared || def.clearTrivia === true);
+      }
       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, resolve2, active, true);
+      return directFixedLexNode(def.parser, resolve2, active, true, cleared);
     }
     if (def.tag === "sequence") {
       if (def.parsers.length < 2 || def.parsers.length > 5) return void 0;
-      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve2, active, pureOnly));
+      const parts = def.parsers.map((part) => directFixedLexNode(part, resolve2, active, pureOnly, cleared));
       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, resolve2, active, pureOnly));
+      if (def.parsers.length < 2 || 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, resolve2, active, pureOnly, cleared));
       if (arms.some((arm) => arm === void 0)) return void 0;
-      const final = classifyFinalChoice(def.parsers, resolve2);
       return {
         kind: "choice",
         arms,
-        firstSets: final.firstSets,
+        parsers: def.parsers,
+        cleared,
         armExpected: def.parsers.map(deriveExpected),
         expected: def.parsers.flatMap(deriveExpected)
       };
     }
     if (def.tag === "not") {
-      const body = directFixedLexNode(def.parser, resolve2, active, true);
+      const body = directFixedLexNode(def.parser, resolve2, active, true, cleared);
       return body === void 0 ? void 0 : {
         kind: "not",
         body,
@@ -2943,18 +3064,28 @@ function directFixedLexNode(parser2, resolve2, active, pureOnly = false) {
       };
     }
     if (def.tag === "optional") {
-      const body = directFixedLexNode(def.parser, resolve2, active, pureOnly);
+      const body = directFixedLexNode(def.parser, resolve2, active, pureOnly, cleared);
       return body === void 0 ? void 0 : { kind: "optional", body };
     }
+    if (def.tag === "many" || def.tag === "oneOrMore") {
+      const body = directFixedLexNode(def.parser, resolve2, active, pureOnly, cleared);
+      return body === void 0 ? void 0 : {
+        kind: "repeat",
+        body,
+        min: def.tag === "many" ? 0 : def.min,
+        max: def.max ?? -1
+      };
+    }
     return void 0;
   } finally {
     active.delete(current);
   }
 }
 function directFixedTokenBody(parser2, resolve2) {
-  const body = directTokenBodyParser(parser2, resolve2);
+  const scope = { cleared: false };
+  const body = directTokenBodyParser(parser2, resolve2, scope);
   if (body === void 0) return void 0;
-  const root = directFixedLexNode(body, resolve2, /* @__PURE__ */ new Set());
+  const root = directFixedLexNode(body, resolve2, /* @__PURE__ */ new Set(), false, scope.cleared);
   return root === void 0 ? void 0 : { kind: "fixed-tree", root };
 }
 function directBalancedTokenBody(parser2, resolve2) {
@@ -4863,17 +4994,59 @@ function buildLexBodyRecognizer(spec, constants) {
   };
 }
 
+// src/table/run-support.ts
+function lineCol(ctx, offset) {
+  const starts = ctx._lineStarts ?? [0];
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return [lo + 1, offset - starts[lo] + 1];
+}
+function spanLines(ctx, start, end) {
+  const s = lineCol(ctx, start), e = lineCol(ctx, end);
+  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+}
+function rawEntry(v, input, s, e) {
+  if (typeof v === "object" && v !== null) {
+    const tg = v._tag;
+    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+  }
+  return {
+    _tag: "leaf",
+    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
+    span: { start: s, end: e }
+  };
+}
+function lead(input, pos) {
+  if (pos >= input.length) return -1;
+  const c = input.charCodeAt(pos);
+  if (c < 55296 || c > 56319) return c;
+  return input.codePointAt(pos) ?? c;
+}
+var EMPTY_KIDS = Object.freeze([]);
+var EMPTY_TRIVIA = Object.freeze([]);
+function collapseEmpty(ctx, build, input, pos, end, readsRaw) {
+  const collected = ctx._cstBuf !== void 0 || ctx._cstChildren !== void 0;
+  if (collected) popCstChild(ctx);
+  const raw = readsRaw ? [rawEntry(void 0, input, pos, end)] : EMPTY_KIDS;
+  const nd = build(EMPTY_KIDS, void 0, { start: pos, end }, raw, EMPTY_TRIVIA, void 0);
+  if (collected) pushCstChild(ctx, nd, ctx._cstBuf?.noRaw === true ? void 0 : rawEntry(nd, input, pos, end));
+  return nd;
+}
+
 // 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_CHOICE = 5;
 var LEX_NODE_NOT = 8;
 var LEX_NODE_OPTIONAL = 9;
+var LEX_NODE_REPEAT = 10;
 function lexProgramDigest(words) {
   let hash = 2166136261;
   for (const word of words) {
@@ -4902,85 +5075,114 @@ function trackLexLines(ctx, input, end) {
   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,
+    match: (input, pos) => {
+      const result = matcher(input, pos);
+      return result < 0 ? -1 : result / 2;
+    },
     run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
+      const result = matcher(input, pos);
+      if (result < 0) {
         ctx._fe = pos;
         ctx._fx = failure;
         if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
         return -1;
       }
+      const end = result / 2;
       if (tracksLines) trackLexLines(ctx, input, end);
       return end;
     }
   };
 }
 function sequence2(a, b) {
+  const am = a.match, bm = b.match, ar = a.run, br = b.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
+      const e0 = am(input, pos);
+      return e0 < 0 ? -1 : bm(input, e0);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      return b.run(input, e0, ctx);
+      return br(input, e0, ctx);
     }
   };
 }
 function sequence3(a, b, c) {
+  const am = a.match, bm = b.match, cm = c.match, ar = a.run, br = b.run, cr = c.run;
   return {
     match: (input, pos) => {
-      const e0 = a.match(input, pos);
+      const e0 = am(input, pos);
       if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
+      const e1 = bm(input, e0);
+      return e1 < 0 ? -1 : cm(input, e1);
     },
     run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
+      const e0 = ar(input, pos, ctx);
       if (e0 < 0) return -1;
       ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
+      const e1 = br(input, e0, ctx);
       if (e1 < 0) return -1;
       ctx._fc = false;
-      return c.run(input, e1, ctx);
+      return cr(input, e1, ctx);
     }
   };
 }
 function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run;
   return {
     match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      return e2 < 0 ? -1 : dm(input, e2);
     },
     run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
       ctx._fc = false;
-      return d.run(input, end, ctx);
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      return dr(input, e2, ctx);
     }
   };
 }
 function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
+  const am = a.match, bm = b.match, cm = c.match, dm = d.match, em = e.match;
+  const ar = a.run, br = b.run, cr = c.run, dr = d.run, er = e.run;
   return {
     match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
+      const e0 = am(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = bm(input, e0);
+      if (e1 < 0) return -1;
+      const e2 = cm(input, e1);
+      if (e2 < 0) return -1;
+      const e3 = dm(input, e2);
+      return e3 < 0 ? -1 : em(input, e3);
     },
     run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
+      const e0 = ar(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = br(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      const e2 = cr(input, e1, ctx);
+      if (e2 < 0) return -1;
+      ctx._fc = false;
+      const e3 = dr(input, e2, ctx);
+      if (e3 < 0) return -1;
       ctx._fc = false;
-      return e.run(input, end, ctx);
+      return er(input, e3, ctx);
     }
   };
 }
@@ -4993,9 +5195,9 @@ function appendExpected(acc, values) {
 function choiceNode(arms, classes, armExpected, choiceExpected) {
   let matchTail = () => -1;
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], next = matchTail;
+    const armMatch = arms[i].match, next = matchTail;
     matchTail = (input, pos) => {
-      const end = arm.match(input, pos);
+      const end = armMatch(input, pos);
       return end < 0 ? next(input, pos) : end;
     };
   }
@@ -5005,7 +5207,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     return -1;
   };
   for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    const armRun = arms[i].run, cls = classes[i], staticExpected = armExpected[i], next = tail;
     tail = (input, pos, ctx, lead2, acc, best) => {
       if (cls !== void 0 && !classHas(cls, lead2)) {
         return next(
@@ -5018,7 +5220,7 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
         );
       }
       ctx._fc = false;
-      const end = arm.run(input, pos, ctx);
+      const end = armRun(input, pos, ctx);
       if (end >= 0) return end;
       const at = ctx._fe ?? pos;
       if (at > best) {
@@ -5045,11 +5247,58 @@ function choiceNode(arms, classes, armExpected, choiceExpected) {
     )
   };
 }
+function exclusiveChoiceNode(arms, classes, choiceFx) {
+  const ascii = (classes.length <= 128 ? new Int8Array(128) : new Int32Array(128)).fill(-1);
+  const hi = [];
+  for (let i = 0; i < classes.length; i++) {
+    const cls = classes[i];
+    for (let c = 0; c < 128; c++) if (cls.ascii[c] === 1) ascii[c] = i;
+    for (let r = 0; r < cls.hi.length; r += 2) hi.push(cls.hi[r], cls.hi[r + 1], i);
+  }
+  const select = (code) => {
+    if (code < 0) return -1;
+    if (code < 128) return ascii[code];
+    for (let r = 0; r < hi.length; r += 3) if (code >= hi[r] && code <= hi[r + 1]) return hi[r + 2];
+    return -1;
+  };
+  let matchArm = () => -1;
+  let selectRun = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const armMatch = arms[i].match, armRun = arms[i].run, nextMatch = matchArm, nextRun = selectRun;
+    matchArm = (selected, input, pos) => selected === i ? armMatch(input, pos) : nextMatch(selected, input, pos);
+    selectRun = (selected, input, pos, ctx) => selected === i ? armRun(input, pos, ctx) : nextRun(selected, input, pos, ctx);
+  }
+  const runArm = (input, pos, ctx) => {
+    const arm = select(lead(input, pos));
+    if (arm >= 0) {
+      ctx._fc = false;
+      const end = selectRun(arm, input, pos, ctx);
+      if (end >= 0) return end;
+      if (committed(ctx)) return -1;
+      const failed = ctx._fx;
+      if (failed !== void 0 && failed.length > 0) {
+        ctx._fe = pos;
+        return -1;
+      }
+    }
+    ctx._fe = pos;
+    ctx._fx = choiceFx;
+    return -1;
+  };
+  return {
+    match: (input, pos) => {
+      const arm = select(lead(input, pos));
+      return arm < 0 ? -1 : matchArm(arm, input, pos);
+    },
+    run: runArm
+  };
+}
 function notNode(body, failure) {
+  const bodyMatch = body.match;
   return {
-    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    match: (input, pos) => bodyMatch(input, pos) < 0 ? pos : -1,
     run: (input, pos, ctx) => {
-      if (body.match(input, pos) < 0) return pos;
+      if (bodyMatch(input, pos) < 0) return pos;
       ctx._fe = pos;
       ctx._fx = failure;
       return -1;
@@ -5057,18 +5306,57 @@ function notNode(body, failure) {
   };
 }
 function optionalNode(body) {
+  const bodyMatch = body.match, bodyRun = body.run;
   return {
     match: (input, pos) => {
-      const end = body.match(input, pos);
+      const end = bodyMatch(input, pos);
       return end < 0 ? pos : end;
     },
     run: (input, pos, ctx) => {
       ctx._fc = false;
-      const end = body.run(input, pos, ctx);
+      const end = bodyRun(input, pos, ctx);
       return end < 0 && !committed(ctx) ? pos : end;
     }
   };
 }
+function repeatNode(item, min, max) {
+  const itemMatch = item.match, itemRun = item.run;
+  return {
+    match: (input, pos) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        const end = itemMatch(input, cur);
+        if (end < 0 || optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    },
+    run: (input, pos, ctx) => {
+      let cur = pos;
+      let count = 0;
+      for (; ; ) {
+        if (max >= 0 && count >= max) break;
+        const optional2 = count >= min && (count > 0 || min === 0);
+        if (optional2 && cur >= input.length) break;
+        ctx._fc = false;
+        const end = itemRun(input, cur, ctx);
+        if (end < 0) {
+          if (committed(ctx)) return -1;
+          break;
+        }
+        if (optional2 && end === cur) break;
+        cur = end;
+        count++;
+      }
+      return count < min ? -1 : cur;
+    }
+  };
+}
 function fixedTreeRunner(words, matchers, classes, expected) {
   const stack = [];
   const pop = () => {
@@ -5096,9 +5384,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       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;
+    if (op === LEX_NODE_CHOICE) {
+      const count = words[at++];
+      const exclusive = words[at++];
+      if (exclusive !== 0 && exclusive !== 1) throw new TypeError("table lexical tree choice has an invalid dispatch mode");
       const choiceFx = expected[words[at++]];
+      if (!Number.isInteger(count) || count < 2 || count > stack.length) {
+        throw new TypeError("table lexical tree choice has an invalid arm count");
+      }
       if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
       const armClasses = [];
       const armFx = [];
@@ -5111,7 +5404,7 @@ function fixedTreeRunner(words, matchers, classes, expected) {
         armFx.push(fx);
       }
       const arms = Array.from({ length: count }, pop).reverse();
-      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      stack.push(exclusive === 1 ? exclusiveChoiceNode(arms, armClasses, choiceFx) : choiceNode(arms, armClasses, armFx, choiceFx));
       continue;
     }
     if (op === LEX_NODE_NOT) {
@@ -5124,6 +5417,14 @@ function fixedTreeRunner(words, matchers, classes, expected) {
       stack.push(optionalNode(pop()));
       continue;
     }
+    if (op === LEX_NODE_REPEAT) {
+      const min = words[at++], max = words[at++];
+      if (!Number.isInteger(min) || min < 0 || !Number.isInteger(max) || max >= 0 && max < min) {
+        throw new TypeError("table lexical tree repeat has invalid bounds");
+      }
+      stack.push(repeatNode(pop(), min, max));
+      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");
@@ -5278,6 +5579,12 @@ function scanRefs(s) {
   refs.push(...s.skip);
   return refs;
 }
+function assemblyExtraIps(prog) {
+  const ips = [];
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) ips.push(r[0]);
+  for (const set of prog.scanSkip ?? []) for (const r of set) ips.push(r[0]);
+  return ips;
+}
 function expandCompact(p) {
   if ("code" in p) return p;
   return ownTableProgram({
@@ -5408,6 +5715,11 @@ function classHas2(cls, code) {
   for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
   return false;
 }
+function dispatchIsExclusive(arms, cc) {
+  const resolved = [];
+  for (const ci of arms) if (ci >= 0) resolved[ci] = resolveClass(cc[ci]);
+  return resolveDispatch(arms, resolved).exclusive;
+}
 function resolveDispatch(arms, cc) {
   const ascii = new Uint8Array(128);
   const hi = [];
@@ -5481,66 +5793,261 @@ function resolveTable(prog) {
   return built;
 }
 
-// src/compiler/degradation.ts
-function formatDegradation(d) {
-  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
-}
-var DETAIL_CAP = 8;
-function formatDegradations(list) {
-  const byCode = /* @__PURE__ */ new Map();
-  for (const d of list) {
-    const bucket = byCode.get(d.code);
-    if (bucket) bucket.push(d);
-    else byCode.set(d.code, [d]);
-  }
-  const out = [];
-  for (const [code, items] of byCode) {
-    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
-    if (items.length > DETAIL_CAP) {
-      out.push(
-        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
-      );
-    }
-  }
-  return out;
+// src/combinators/adjacency.ts
+function adjacencyOf(p) {
+  return p._def.tag === "adjacency" ? p._def : null;
 }
-var _sinks = [];
-function beginDegradationCapture() {
-  _sinks.push(/* @__PURE__ */ new Map());
+function adjacencyExpected(def) {
+  if (def.polarity === "adjacent") return "adjacent";
+  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
 }
-function degradationCaptureDepth() {
-  return _sinks.length;
+function holdsAdjacency(input, cur, ctx, def) {
+  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
 }
-function unwindDegradationCapture(depth) {
-  const found = [];
-  while (_sinks.length > depth) {
-    const sink = _sinks.pop();
-    found.unshift(...sink.values());
-  }
-  return found;
+function adjacencyHolds(input, cur, ctx, negated, kinds) {
+  const end = probeTriviaEnd(input, cur, ctx);
+  if (!negated) return end === cur;
+  if (end === cur) return false;
+  if (kinds === void 0) return true;
+  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
+  const spec = analyzeLabeledTrivia(ctx.trivia);
+  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
 }
-function resolveDegradationLevel(explicit) {
-  if (explicit !== void 0) return explicit;
-  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
-  if (env === "off" || env === "warn" || env === "error") return env;
-  return "warn";
+function adjacencyFail(pos, def) {
+  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
 }
-function degradationKey(d) {
-  return JSON.stringify([d.code, d.where, d.subject]);
+var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
+function adjacencyMisuse(polarity) {
+  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
 }
-function recordDegradation(d) {
-  const level = resolveDegradationLevel();
-  if (level === "off") return;
-  const key = degradationKey(d);
-  const sink = _sinks[_sinks.length - 1];
-  if (sink) {
-    if (!sink.has(key)) sink.set(key, d);
-    return;
-  }
-  if (_immediate.has(key)) return;
-  _immediate.add(key);
-  if (level === "error") throw new Error(`parseman: degraded compilation path
-${formatDegradation(d)}`);
+function adjacencyCombinator(def) {
+  const meta = {
+    // Zero-width and never leading (sequence() rejects index 0), so it contributes
+    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
+    // rather than letting `any` poison the enclosing choice's dispatch.
+    firstSet: { kind: "any" },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "adjacency",
+    _meta: meta,
+    _def: def,
+    parse() {
+      throw adjacencyMisuse(def.polarity);
+    }
+  };
+}
+function adjacent() {
+  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
+}
+function notAdjacent(options) {
+  const kinds = options?.kinds;
+  if (kinds !== void 0) {
+    if (!Array.isArray(kinds) || kinds.length === 0) {
+      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
+    }
+    for (const k of kinds) {
+      if (typeof k !== "string" || k.length === 0) {
+        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
+      }
+    }
+  }
+  return adjacencyCombinator(
+    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
+  );
+}
+
+// src/combinators/sequence.ts
+function sequence(...parsers) {
+  let adjacency = null;
+  for (let i = 0; i < parsers.length; i++) {
+    const a = adjacencyOf(parsers[i]);
+    if (a === null) continue;
+    if (i === 0) {
+      throw new TypeError(
+        `sequence(): ${a.polarity}() cannot be the FIRST term \u2014 an adjacency assertion tests the gap after the PRECEDING term. Put a concrete term first.`
+      );
+    }
+    ;
+    (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
+  }
+  const hasAdjacency = adjacency !== null;
+  let leading = null;
+  for (let i = 1; i < parsers.length; i++) {
+    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
+  }
+  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
+  const meta = {
+    // Union through the nullable prefix — a leading optional()/many() lets a later
+    // term's first char start the sequence. Just `parsers[0]` under-approximates.
+    firstSet: sequenceFirstSet(parsers),
+    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
+    isTrivia: false
+  };
+  const def = { tag: "sequence", parsers };
+  const scalarParsers = parsers.map(scalarOf);
+  const parseScalar = (input, pos, ctx) => {
+    let cur = pos;
+    if (strictArity !== 0) {
+      cur = scalarParsers[0](input, cur, ctx);
+      if (cur < 0) return cur;
+      const first = ctx._sv;
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[1](input, cur, ctx);
+      if (cur < 0) return cur;
+      const second = ctx._sv;
+      if (strictArity === 2) {
+        ctx._sv = def.valueUnused ? void 0 : [first, second];
+        return cur;
+      }
+      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
+      cur = scalarParsers[2](input, cur, ctx);
+      if (cur < 0) return cur;
+      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
+      return cur;
+    }
+    const values = def.valueUnused ? void 0 : [];
+    for (let i = 0; i < scalarParsers.length; i++) {
+      let termPos = cur;
+      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
+      const end = scalarParsers[i](input, termPos, ctx);
+      if (end < 0) return end;
+      if (values !== void 0) values.push(ctx._sv);
+      if (end > termPos || termPos === cur) cur = end;
+    }
+    ctx._sv = values;
+    return cur;
+  };
+  let followSentinels;
+  return {
+    _tag: "sequence",
+    _meta: meta,
+    _def: def,
+    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
+    parse(input, pos, ctx) {
+      const tolerant = ctx._tolerant === true;
+      if (tolerant) {
+        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
+          parsers.slice(i + 1).reduce(
+            (set, parser2) => union(set, firstSetOf(parser2)),
+            { kind: "empty" }
+          )
+        ));
+      }
+      const inheritedSync = ctx._sync;
+      const deferredTrivia = needsDeferredTriviaCommit(ctx);
+      const values = def.valueUnused ? void 0 : [];
+      let cur = pos;
+      try {
+        for (let i = 0; i < parsers.length; i++) {
+          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
+          const assertion = adjacency?.[i];
+          if (assertion) {
+            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
+            if (values !== void 0) values.push(null);
+            continue;
+          }
+          let termPos = cur;
+          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (ctx.trivia && i > 0) {
+            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
+          }
+          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
+          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
+          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
+          if (leading?.[i] === true) LEAD.at = cur;
+          const result = parsers[i].parse(input, termPos, ctx);
+          if (!result.ok) return result;
+          if (values !== void 0) values.push(result.value);
+          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
+          else if (deferredTrivia) {
+            rollbackScannedTriviaAt(
+              ctx,
+              markTlog,
+              scanTlog,
+              markLog,
+              scanLog,
+              markRootLog,
+              scanRootLog
+            );
+          }
+        }
+      } finally {
+        if (tolerant) ctx._sync = inheritedSync;
+      }
+      return {
+        ok: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+        value: values ?? void 0,
+        span: { start: pos, end: cur }
+      };
+    }
+  };
+}
+
+// src/compiler/degradation.ts
+function formatDegradation(d) {
+  return `[parseman] degraded [${d.code}] ${d.where}: ${d.subject} \u2014 ${d.fellBackTo}; otherwise ${d.otherwise}`;
+}
+var DETAIL_CAP = 8;
+function formatDegradations(list) {
+  const byCode = /* @__PURE__ */ new Map();
+  for (const d of list) {
+    const bucket = byCode.get(d.code);
+    if (bucket) bucket.push(d);
+    else byCode.set(d.code, [d]);
+  }
+  const out = [];
+  for (const [code, items] of byCode) {
+    for (const d of items.slice(0, DETAIL_CAP)) out.push(formatDegradation(d));
+    if (items.length > DETAIL_CAP) {
+      out.push(
+        `[parseman] degraded [${code}] +${items.length - DETAIL_CAP} more site(s) not listed (${items.length} total). Set PARSEMAN_DEGRADATION=error to fail the build on these.`
+      );
+    }
+  }
+  return out;
+}
+var _sinks = [];
+function beginDegradationCapture() {
+  _sinks.push(/* @__PURE__ */ new Map());
+}
+function degradationCaptureDepth() {
+  return _sinks.length;
+}
+function unwindDegradationCapture(depth) {
+  const found = [];
+  while (_sinks.length > depth) {
+    const sink = _sinks.pop();
+    found.unshift(...sink.values());
+  }
+  return found;
+}
+function resolveDegradationLevel(explicit) {
+  if (explicit !== void 0) return explicit;
+  const env = typeof process !== "undefined" ? process.env?.PARSEMAN_DEGRADATION : void 0;
+  if (env === "off" || env === "warn" || env === "error") return env;
+  return "warn";
+}
+function degradationKey(d) {
+  return JSON.stringify([d.code, d.where, d.subject]);
+}
+function recordDegradation(d) {
+  const level = resolveDegradationLevel();
+  if (level === "off") return;
+  const key = degradationKey(d);
+  const sink = _sinks[_sinks.length - 1];
+  if (sink) {
+    if (!sink.has(key)) sink.set(key, d);
+    return;
+  }
+  if (_immediate.has(key)) return;
+  _immediate.add(key);
+  if (level === "error") throw new Error(`parseman: degraded compilation path
+${formatDegradation(d)}`);
   console.warn(formatDegradation(d));
 }
 var _immediate = /* @__PURE__ */ new Set();
@@ -5659,91 +6166,620 @@ function splitTopLevel(inner) {
       last = i + 1;
     }
   }
-  if (depth !== 0 || angle !== 0) return null;
-  parts.push(inner.slice(last));
-  return parts;
+  if (depth !== 0 || angle !== 0) return null;
+  parts.push(inner.slice(last));
+  return parts;
+}
+function isConfirmableParam(part) {
+  const head = PARAM_HEAD_RE.exec(part);
+  if (!head) return false;
+  const rest = part.slice(head[0].length);
+  if (rest === "") return true;
+  if (rest[0] !== ":") return false;
+  return !hasDefaultAssign(rest.slice(1));
+}
+function hasDefaultAssign(annotation) {
+  for (let i = 0; i < annotation.length; i++) {
+    if (annotation[i] !== "=") continue;
+    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
+      i++;
+      continue;
+    }
+    const prev = annotation[i - 1];
+    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
+    return true;
+  }
+  return false;
+}
+function buildAnalysisSrc(def) {
+  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
+}
+var RESOLVER_REASONS = {
+  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
+  "arguments": "its body references `arguments`",
+  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
+  "not-a-function": "the binding it names is not a function declaration",
+  "unresolved-import": "its module could not be resolved or parsed",
+  "not-found": "the name did not resolve to any binding",
+  "computed": "it is a computed expression",
+  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
+  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
+};
+function unconfirmableReason(def, src) {
+  const declared = def.buildArityUnresolved;
+  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
+  const s = src.trim();
+  const params = s.slice(0, s.indexOf(")") + 1);
+  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
+  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
+  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
+    return "it names a binding this build could not resolve to a function declaration";
+  }
+  return "its parameter list could not be parsed";
+}
+function confirmedArityForDef(def) {
+  if (def.buildArity !== void 0) return def.buildArity;
+  const src = buildAnalysisSrc(def);
+  const arity = confirmedBuildArity(src);
+  if (arity !== null) return arity;
+  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
+  recordDegradation({
+    code: "build-arity-unconfirmed",
+    severity: "warn",
+    where: `node("${def.type ?? "<inferred>"}")`,
+    subject,
+    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and hands it \`_ctx.state\` on every match`,
+    otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
+  });
+  return null;
+}
+function buildReadsRaw(def) {
+  if (!def.build) return true;
+  if (def.buildRawUnused === true) return false;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 4;
+}
+function buildReadsTrivia(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 5;
+}
+function buildReadsState(def) {
+  if (!def.build) return true;
+  const arity = confirmedArityForDef(def);
+  if (arity === null) return true;
+  return arity >= 6;
+}
+
+// src/combinators/token.ts
+function semanticLeafValue(_ctx, _input, _start, _end, value) {
+  return value;
+}
+function sourceLeafValue(ctx, input, start, end, value) {
+  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
+}
+function token(root) {
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "token",
+    _meta: meta,
+    _def: { tag: "token", parser: root },
+    parse(input, pos, ctx) {
+      const savedTrivia = ctx.trivia;
+      const savedKinds = ctx.triviaKindLabels;
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const savedRootTriviaLog = ctx._rootTriviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      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 result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx.trivia = savedTrivia;
+        ctx.triviaKindLabels = savedKinds;
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+        ctx._rootTriviaLog = savedRootTriviaLog;
+      }
+      if (!result.ok) return result;
+      const span = result.span;
+      const value = input.slice(pos, span.end);
+      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span });
+      return { ok: true, value, span };
+    }
+  };
+}
+function makeLeaf(root, fn, sourceCstValue) {
+  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
+  const meta = {
+    firstSet: root._meta.firstSet,
+    canMatchNewline: root._meta.canMatchNewline,
+    isTrivia: false
+  };
+  return {
+    _tag: "leaf",
+    _meta: meta,
+    _def: {
+      tag: "leaf",
+      parser: root,
+      fn,
+      ...sourceCstValue ? { cstValue: "source" } : {}
+    },
+    parse(input, pos, ctx) {
+      const savedBuf = ctx._cstBuf;
+      const savedChildren = ctx._cstChildren;
+      const savedLeaves = ctx._cstLeaves;
+      const savedRaw = ctx._cstRawChildren;
+      const savedTriviaLog = ctx._cstTriviaLog;
+      const savedOuterTriviaLog = ctx._triviaLog;
+      const wasCapturing = cstCaptureActive(ctx);
+      ctx._cstBuf = void 0;
+      ctx._cstChildren = void 0;
+      ctx._cstLeaves = void 0;
+      ctx._cstRawChildren = void 0;
+      ctx._cstTriviaLog = void 0;
+      ctx._triviaLog = void 0;
+      let result;
+      try {
+        result = root.parse(input, pos, ctx);
+      } finally {
+        ctx._cstBuf = savedBuf;
+        ctx._cstChildren = savedChildren;
+        ctx._cstLeaves = savedLeaves;
+        ctx._cstRawChildren = savedRaw;
+        ctx._cstTriviaLog = savedTriviaLog;
+        ctx._triviaLog = savedOuterTriviaLog;
+      }
+      if (!result.ok) return result;
+      const value = fn(result.value, result.span);
+      if (wasCapturing) pushCstLeaf(ctx, {
+        _tag: "leaf",
+        value: cstValue(ctx, input, pos, result.span.end, value),
+        span: result.span
+      });
+      return { ok: true, value, span: result.span };
+    }
+  };
+}
+function leaf(root, fn) {
+  return makeLeaf(root, fn, false);
+}
+function sourceLeaf(root, fn) {
+  return makeLeaf(root, fn, true);
+}
+
+// src/compiler/value-usage.ts
+function markUnusedValues(root) {
+  const seenConsumed = /* @__PURE__ */ new WeakSet();
+  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
+  const mark = (def, consumed) => {
+    if (consumed) def.valueUnused = false;
+    else if (def.valueUnused !== false) def.valueUnused = true;
+  };
+  const visit = (c, consumed) => {
+    const seen = consumed ? seenConsumed : seenUnconsumed;
+    if (seen.has(c)) return;
+    seen.add(c);
+    const def = c._def;
+    switch (def.tag) {
+      case "many":
+      case "oneOrMore":
+        mark(def, consumed);
+        visit(def.parser, consumed);
+        return;
+      case "optional":
+        visit(def.parser, consumed);
+        return;
+      case "sequence":
+        mark(def, consumed);
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "choice":
+        for (const p of def.parsers) visit(p, consumed);
+        return;
+      case "dispatch":
+        visit(def.selector, consumed);
+        for (const entry of def.cases) visit(entry.parser, consumed);
+        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
+        if (def.otherwise) visit(def.otherwise, consumed);
+        return;
+      case "node":
+        visit(def.parser, false);
+        return;
+      case "transform":
+        visit(def.parser, true);
+        return;
+      case "field":
+        visit(def.parser, true);
+        return;
+      case "sepBy":
+        visit(def.parser, true);
+        visit(def.separator, false);
+        return;
+      case "not":
+      case "peek":
+        visit(def.parser, false);
+        return;
+      case "grammar":
+        visit(def.parser, consumed);
+        if (def.triviaParser) visit(def.triviaParser, false);
+        return;
+      case "recover":
+        visit(def.parser, consumed);
+        visit(def.sentinel, false);
+        return;
+      case "token":
+        visit(def.parser, false);
+        return;
+      case "label":
+      case "trivia":
+      case "attempt":
+      case "withCtx":
+      case "expect":
+        visit(def.parser, consumed);
+        return;
+      case "leaf":
+        visit(def.parser, true);
+        return;
+      case "lazy":
+        return;
+      default:
+        return;
+    }
+  };
+  const resolveRoot = (c) => {
+    const guard = /* @__PURE__ */ new Set();
+    let cur = c;
+    while (!guard.has(cur)) {
+      const d = cur._def;
+      if (d.tag === "grammar") {
+        guard.add(cur);
+        cur = d.parser;
+        continue;
+      }
+      if (d.tag !== "lazy") return cur;
+      guard.add(cur);
+      try {
+        cur = d.thunk();
+      } catch {
+        return c;
+      }
+    }
+    return cur;
+  };
+  visit(resolveRoot(root), true);
+}
+
+// src/cst/root-trivia-scope.ts
+var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
+function refuseUnclassifiedRootScope(strict) {
+  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
+}
+
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+var TRACK_LINES_ON = () => true;
+var TRACK_LINES_OFF = () => false;
+var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  const opaqueRootCapture = opts.rootCapture === "opaque";
+  if (opaqueRootCapture && opts.trivia === void 0) {
+    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
+  }
+  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
+  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
+  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
+  const forceCaptureTrivia = opts.captureTrivia === true;
+  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;
+  const rootScalar = scalarOf(root);
+  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
+  const parseScalar = scalarEligible ? (input, pos, ctx) => {
+    const savedTrivia = ctx.trivia;
+    const savedLabels = ctx.triviaKindLabels;
+    if (clearTrivia) {
+      ctx.trivia = void 0;
+      ctx.triviaKindLabels = void 0;
+    } else if (scopeTrivia !== void 0) {
+      ctx.trivia = scopeTrivia;
+      ctx.triviaKindLabels = scopeLabels;
+    }
+    const end = rootScalar(input, pos, ctx);
+    ctx.trivia = savedTrivia;
+    ctx.triviaKindLabels = savedLabels;
+    return end;
+  } : void 0;
+  let publicScalar;
+  const grammar = {
+    _tag: "grammar",
+    _meta: {
+      ...root._meta,
+      // Trivia classification describes this grammar's own active trivia
+      // scope. A directly nested grammar may have classified trivia of its
+      // own, but that must not advertise classification for this wrapper.
+      triviaKindLabels: void 0,
+      rootTriviaClassified: void 0,
+      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
+      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
+    },
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: scopeTrivia,
+      clearTrivia,
+      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false,
+      constructionTrackLines: trackLinesPolicy,
+      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
+    },
+    _parseScalar: parseScalar,
+    parse(input, pos, _ctx) {
+      if (pos === void 0 && _ctx === void 0) {
+        publicScalar ??= scalarRootOf(grammar) ?? null;
+        if (publicScalar) {
+          const ctx2 = createParseContext();
+          const end = publicScalar(input, 0, ctx2);
+          if (end < 0) {
+            const at = ~end;
+            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
+          }
+          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+        }
+      }
+      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
+      const trackLines = trackLinesOf(_ctx);
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = _ctx === void 0 ? createParseContext() : { ..._ctx };
+      ctx.trackLines = trackLines;
+      if (lineIndex) ctx._lineIndex = lineIndex;
+      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+      if (clearTrivia) {
+        ctx.trivia = void 0;
+        ctx.triviaKindLabels = void 0;
+      } else if (scopeTrivia !== void 0) {
+        ctx.trivia = scopeTrivia;
+        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
+      }
+      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
+      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
+      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
+      if (opaqueRootCapture) ctx._rootTriviaCapture = false;
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+  return grammar;
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+var _analyzed = /* @__PURE__ */ new WeakSet();
+function parse(combinator, input, opts = {}) {
+  if (!_analyzed.has(combinator)) {
+    _analyzed.add(combinator);
+    markUnusedValues(combinator);
+  }
+  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
+    return combinator.parse(input);
+  }
+  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
+  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
+  const lineIndex = lineContext?.lineIndex;
+  const _errors = opts.recover ? [] : void 0;
+  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
+  const grammarTrivia = combinator._meta.grammarTrivia;
+  const grammarScanSkip = combinator._meta.grammarScanSkip;
+  const ctx = createParseContext();
+  ctx.trackLines = trackLines;
+  if (lineIndex) ctx._lineIndex = lineIndex;
+  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
+  if (grammarTrivia !== void 0) {
+    ctx.trivia = grammarTrivia;
+    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
+  }
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (_errors !== void 0) ctx._errors = _errors;
+  if (_probe !== void 0) ctx._probe = _probe;
+  const result = combinator.parse(input, 0, ctx);
+  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
+  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
 }
-function isConfirmableParam(part) {
-  const head = PARAM_HEAD_RE.exec(part);
-  if (!head) return false;
-  const rest = part.slice(head[0].length);
-  if (rest === "") return true;
-  if (rest[0] !== ":") return false;
-  return !hasDefaultAssign(rest.slice(1));
+
+// src/combinators/attempt.ts
+function containOption(options) {
+  if (options === void 0) return false;
+  for (const key of Object.keys(options)) {
+    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
+  }
+  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
+    throw new TypeError("attempt(): `contain` must be a boolean");
+  }
+  return options.contain === true;
 }
-function hasDefaultAssign(annotation) {
-  for (let i = 0; i < annotation.length; i++) {
-    if (annotation[i] !== "=") continue;
-    if (annotation[i + 1] === ">" || annotation[i + 1] === "=") {
-      i++;
-      continue;
+function attempt(parser2, options) {
+  const contain = containOption(options);
+  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
+  let failExpected;
+  return {
+    _tag: "attempt",
+    _meta: parser2._meta,
+    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
+    parse(input, pos, ctx) {
+      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
+        if (failExpected === void 0) {
+          const e = deriveExpected(parser2);
+          failExpected = e.length > 0 ? e : [parser2._tag];
+        }
+        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
+      }
+      const mark = saveCstMark(ctx);
+      const log = ctx._triviaLog?.length;
+      const rootLog = ctx._rootTriviaLog?.length;
+      const split = ctx._columnsSplit;
+      const result = parser2.parse(input, pos, ctx);
+      if (result.ok) return result;
+      rollbackCstCapture(ctx, mark);
+      ctx._columnsSplit = split;
+      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
+      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
+      if (result.committed && !contain) return result;
+      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
     }
-    const prev = annotation[i - 1];
-    if (prev === "<" || prev === ">" || prev === "!" || prev === "=") continue;
-    return true;
+  };
+}
+
+// src/table/factor-choice.ts
+var DERIVED = /* @__PURE__ */ new Set(["_tag", "_meta", "_def", "_parseScalar", "_stickyRegex", "parse"]);
+function isCombinator(v) {
+  return typeof v === "object" && v !== null && "_def" in v && "_meta" in v;
+}
+function sameComb(a, b, depth) {
+  if (a === b) return true;
+  if (depth > 32 || a._tag !== b._tag) return false;
+  for (const k of Object.keys(a)) if (!DERIVED.has(k)) return false;
+  for (const k of Object.keys(b)) if (!DERIVED.has(k)) return false;
+  return sameFields(a._def, b._def, depth, void 0);
+}
+function sameValue(u, v, depth) {
+  if (u === v) return true;
+  if (isCombinator(u) && isCombinator(v)) return sameComb(u, v, depth + 1);
+  if (Array.isArray(u) && Array.isArray(v)) return u.length === v.length && u.every((x, i) => sameValue(x, v[i], depth));
+  if (typeof u === "object" && u !== null && typeof v === "object" && v !== null && Object.getPrototypeOf(u) === Object.prototype && Object.getPrototypeOf(v) === Object.prototype) {
+    return sameFields(u, v, depth, void 0);
   }
   return false;
 }
-function buildAnalysisSrc(def) {
-  return def.buildSigSrc ?? def.buildSrc ?? def.build.toString();
-}
-var RESOLVER_REASONS = {
-  "rest-parameter": "its parameter list uses a rest parameter, so the declared arity is unbounded",
-  "arguments": "its body references `arguments`",
-  "reassigned": "the binding it names is reassigned, so the function read here is not decidable",
-  "not-a-function": "the binding it names is not a function declaration",
-  "unresolved-import": "its module could not be resolved or parsed",
-  "not-found": "the name did not resolve to any binding",
-  "computed": "it is a computed expression",
-  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
-  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
-};
-function unconfirmableReason(def, src) {
-  const declared = def.buildArityUnresolved;
-  if (declared !== void 0 && RESOLVER_REASONS[declared]) return RESOLVER_REASONS[declared];
-  const s = src.trim();
-  const params = s.slice(0, s.indexOf(")") + 1);
-  if (params.includes("...")) return RESOLVER_REASONS["rest-parameter"];
-  if (/\barguments\b/.test(s)) return RESOLVER_REASONS["arguments"];
-  if (/^[A-Za-z_$][\w$]*(\s*\.\s*[A-Za-z_$][\w$]*)?$/.test(s)) {
-    return "it names a binding this build could not resolve to a function declaration";
+function sameFields(x, y, depth, skip) {
+  const kx = Object.keys(x).filter((k) => k !== skip && x[k] !== void 0);
+  const ky = Object.keys(y).filter((k) => k !== skip && y[k] !== void 0);
+  if (kx.length !== ky.length) return false;
+  for (const k of kx) {
+    if (!(k in y)) return false;
+    const u = x[k];
+    const v = y[k];
+    if (k === "fn" && typeof u === "function" && typeof v === "function" && u !== v) {
+      if (typeof x.fnSrc !== "string" || x.fnSrc === "" || x.fnSrc !== y.fnSrc) return false;
+      continue;
+    }
+    if (!sameValue(u, v, depth)) return false;
   }
-  return "its parameter list could not be parsed";
-}
-function confirmedArityForDef(def) {
-  if (def.buildArity !== void 0) return def.buildArity;
-  const src = buildAnalysisSrc(def);
-  const arity = confirmedBuildArity(src);
-  if (arity !== null) return arity;
-  const subject = `build reducer \`${(def.buildSrc ?? "<runtime fn>").trim().split("\n")[0].slice(0, 60)}\``;
-  recordDegradation({
-    code: "build-arity-unconfirmed",
-    severity: "warn",
-    where: `node("${def.type ?? "<inferred>"}")`,
-    subject,
-    fellBackTo: `could not confirm its declared arity \u2014 ${unconfirmableReason(def, src)} \u2014 so this node captures children, fields and raw children, logs trivia, and clones \`_ctx.state\` on every match`,
-    otherwise: "only the tiers the reducer actually declares would be captured (arity >= 1 children, >= 2 fields, >= 4 raw, >= 5 trivia, >= 6 state). Declare it with `node(..., { buildArity: n })` if it cannot be derived"
-  });
-  return null;
-}
-function buildReadsRaw(def) {
-  if (!def.build) return true;
-  if (def.buildRawUnused === true) return false;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 4;
-}
-function buildReadsTrivia(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 5;
+  return true;
 }
-function buildReadsState(def) {
-  if (!def.build) return true;
-  const arity = confirmedArityForDef(def);
-  if (arity === null) return true;
-  return arity >= 6;
+function rewrap(w, body) {
+  const d = w._def;
+  let out;
+  if (d.tag === "leaf") {
+    out = d.cstValue === "source" ? sourceLeaf(body, d.fn) : leaf(body, d.fn);
+    if (d.fnSrc !== void 0) out._def.fnSrc = d.fnSrc;
+  } else if (d.tag === "grammar") {
+    out = d.clearTrivia === true ? noTrivia(body) : parser({ trivia: d.triviaParser ?? null }, body);
+  } else return void 0;
+  return sameFields(d, out._def, 0, "parser") ? out : void 0;
+}
+function unusedOf(seq) {
+  return seq._def.tag === "sequence" && seq._def.valueUnused === true;
+}
+function never(c) {
+  const t2 = c._def.tag;
+  return t2 === "optional" || t2 === "many";
+}
+function factorSharedEnds(d) {
+  const arms = d.parsers;
+  if (arms.length < 2) return void 0;
+  if (d.strategy.tag !== "firstMatch" && d.strategy.tag !== "sharedPrefix") return void 0;
+  if (d.gates.some((g) => g !== null) || d.autoNot.some((a) => a !== null)) return void 0;
+  const shapes = [];
+  for (const arm of arms) {
+    const wrappers = [];
+    let c = arm;
+    while ((c._def.tag === "leaf" || c._def.tag === "grammar") && wrappers.length < 4) {
+      wrappers.push(c);
+      c = c._def.parser;
+    }
+    if (c._def.tag !== "sequence" || c._def.parsers.length < 2) return void 0;
+    shapes.push({ wrappers, terms: c._def.parsers, seq: c });
+  }
+  const first = shapes[0];
+  const n = first.terms.length;
+  for (const s of shapes) {
+    if (s.wrappers.length !== first.wrappers.length || s.terms.length !== n) return void 0;
+    if (unusedOf(s.seq) !== unusedOf(first.seq)) return void 0;
+    for (let j = 0; j < s.wrappers.length; j++) {
+      const a = first.wrappers[j]._def;
+      const b = s.wrappers[j]._def;
+      if (a.tag !== b.tag || !sameFields(a, b, 0, "parser")) return void 0;
+    }
+  }
+  let at = -1;
+  for (let i = 0; i < n; i++) {
+    if (shapes.every((s) => sameComb(s.terms[i], first.terms[i], 0))) continue;
+    if (at >= 0) return void 0;
+    at = i;
+  }
+  if (at < 0) return void 0;
+  for (let i = at + 1; i < n; i++) if (!never(first.terms[i])) return void 0;
+  if (arms.some((a) => mayCommitFailure(a))) return void 0;
+  const middle = choice(...shapes.map((s) => s.terms[at]));
+  if (middle._def.tag === "choice" && middle._def.autoNot.some((a) => a !== null)) return void 0;
+  const st = middle._def.tag === "choice" ? middle._def.strategy : void 0;
+  if (st === void 0 || st.tag !== "firstMatch" && st.tag !== "sharedPrefix" && !(st.tag === "literalsLongestFirst" && st.sortedIndices.every((x, i) => x === i))) return void 0;
+  let out = sequence(
+    ...[...first.terms.slice(0, at), middle, ...first.terms.slice(at + 1)]
+  );
+  if (unusedOf(first.seq)) {
+    out._def.valueUnused = true;
+  }
+  for (let j = first.wrappers.length - 1; j >= 0 && out !== void 0; j--) out = rewrap(first.wrappers[j], out);
+  return out === void 0 ? void 0 : attempt(out);
 }
 
 // src/compiler/fields.ts
@@ -5860,6 +6896,7 @@ var OP_SCOPE_PLAIN = 41;
 var OP_LEX_BODY = 42;
 var OP_LEX_PROGRAM = 43;
 var OP_SOURCE_LEAF = 44;
+var OP_RGATE = 45;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -5879,6 +6916,7 @@ var OP_NAMES = {
   [OP_PEEK]: "PEEK",
   [OP_LEAF]: "LEAF",
   [OP_SOURCE_LEAF]: "SOURCE_LEAF",
+  [OP_RGATE]: "RGATE",
   [OP_EMPTY]: "EMPTY",
   [OP_LIT_TRACK]: "LIT_TRACK",
   [OP_RX_TRACK]: "RX_TRACK",
@@ -5909,71 +6947,6 @@ var OP_NAMES = {
   [OP_LEX_PROGRAM]: "LEX_PROGRAM"
 };
 
-// src/combinators/adjacency.ts
-function adjacencyOf(p) {
-  return p._def.tag === "adjacency" ? p._def : null;
-}
-function adjacencyExpected(def) {
-  if (def.polarity === "adjacent") return "adjacent";
-  return def.kinds === void 0 ? "notAdjacent" : `notAdjacent(${def.kinds.join("|")})`;
-}
-function holdsAdjacency(input, cur, ctx, def) {
-  return adjacencyHolds(input, cur, ctx, def.polarity === "notAdjacent", def.kinds);
-}
-function adjacencyHolds(input, cur, ctx, negated, kinds) {
-  const end = probeTriviaEnd(input, cur, ctx);
-  if (!negated) return end === cur;
-  if (end === cur) return false;
-  if (kinds === void 0) return true;
-  const want = resolveAdjacencyKindMask(ctx.trivia, kinds);
-  const spec = analyzeLabeledTrivia(ctx.trivia);
-  return (triviaKindMaskAt(input, cur, spec, ctx.state) & want) !== 0;
-}
-function adjacencyFail(pos, def) {
-  return { ok: false, expected: [adjacencyExpected(def)], span: { start: pos, end: pos } };
-}
-var NO_STANDALONE_PARSE = "adjacency assertions are boundary tests: use adjacent()/notAdjacent() as a NON-FIRST term of a sequence(), where the preceding term defines the gap being asserted.";
-function adjacencyMisuse(polarity) {
-  return new TypeError(`${polarity}(): ${NO_STANDALONE_PARSE}`);
-}
-function adjacencyCombinator(def) {
-  const meta = {
-    // Zero-width and never leading (sequence() rejects index 0), so it contributes
-    // no first char. `isZeroWidthAssertion` drops it from a sequence's first-set
-    // rather than letting `any` poison the enclosing choice's dispatch.
-    firstSet: { kind: "any" },
-    canMatchNewline: false,
-    isTrivia: false
-  };
-  return {
-    _tag: "adjacency",
-    _meta: meta,
-    _def: def,
-    parse() {
-      throw adjacencyMisuse(def.polarity);
-    }
-  };
-}
-function adjacent() {
-  return adjacencyCombinator({ tag: "adjacency", polarity: "adjacent" });
-}
-function notAdjacent(options) {
-  const kinds = options?.kinds;
-  if (kinds !== void 0) {
-    if (!Array.isArray(kinds) || kinds.length === 0) {
-      throw new TypeError("notAdjacent({ kinds }): kinds must be a non-empty array of trivia category names.");
-    }
-    for (const k of kinds) {
-      if (typeof k !== "string" || k.length === 0) {
-        throw new TypeError(`notAdjacent({ kinds }): every kind must be a non-empty string, got ${JSON.stringify(k)}.`);
-      }
-    }
-  }
-  return adjacencyCombinator(
-    kinds === void 0 ? { tag: "adjacency", polarity: "notAdjacent" } : { tag: "adjacency", polarity: "notAdjacent", kinds: [...kinds] }
-  );
-}
-
 // src/combinators/node.ts
 function unwrapChild(child) {
   return child !== null && typeof child === "object" && child._tag === "leaf" ? child.value : child;
@@ -6035,7 +7008,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   }
   const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || buildArity !== void 0 || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...buildArity !== void 0 ? { buildArity } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || (build ? buildReadsTrivia(def) : project === void 0);
-  const clonesState = build ? buildReadsState(def) : project === void 0;
+  const readsState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
   const capturesFields = hasOwnFields && (build ? buildReadsFields(def) : project === void 0);
   const guardable = combinator._meta.firstSet.kind !== "any" && !matchesEmpty(combinator);
@@ -6076,12 +7049,11 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       ctx._triviaCaptureMask = savedMask;
       const { children: children2, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const st = readsState ? ctx.state : void 0;
       const nodeType = def.type ?? missingInferredType();
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
-      const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, ctx.state, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, ctx.state, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry2);
@@ -6091,42 +7063,6 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   };
 }
 
-// src/combinators/trivia-boundary.ts
-var MAX_DEPTH = 12;
-function hasOwnTriviaBoundary(p, depth = MAX_DEPTH) {
-  if (depth === 0) return true;
-  const d = p._def;
-  switch (d.tag) {
-    // Multi-term forms: the gaps BETWEEN terms are the ambient-trivia positions.
-    case "sequence":
-      return d.parsers.length > 1;
-    case "many":
-    case "oneOrMore":
-    case "sepBy":
-      return true;
-    // Transparent wrappers — they add no position, so ask what they wrap.
-    case "node":
-    case "transform":
-    case "leaf":
-    case "label":
-    case "field":
-    case "token":
-    case "attempt":
-    case "optional":
-    case "expect":
-    case "withCtx":
-    case "recover":
-    case "trivia":
-      return hasOwnTriviaBoundary(d.parser, depth - 1);
-    // An alternation adds no position either, but ONE arm that has one is enough
-    // to make the scope meaningful for this rule.
-    case "choice":
-      return d.parsers.some((a) => hasOwnTriviaBoundary(a, depth - 1));
-    default:
-      return false;
-  }
-}
-
 // src/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
   let source = fnSrc;
@@ -6347,13 +7283,16 @@ var Encoder = class {
           }
           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));
+            const final = classifyFinalChoice(
+              node2.parsers,
+              this.refResolver(),
+              node2.cleared ? void 0 : this.activeTrivia
+            );
+            const classes = final.firstSets.map((first, i) => final.nullable[i] ? -1 : this.charClass(first));
+            const exclusive = final.exclusive && classes.every((cls) => cls >= 0);
+            words.push(LEX_NODE_CHOICE, node2.arms.length, exclusive ? 1 : 0, 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]));
+              words.push(classes[i], this.expected(node2.armExpected[i]));
             }
             return true;
           }
@@ -6365,6 +7304,10 @@ var Encoder = class {
             if (!emitNode(node2.body)) return false;
             words.push(LEX_NODE_OPTIONAL);
             return true;
+          case "repeat":
+            if (!emitNode(node2.body)) return false;
+            words.push(LEX_NODE_REPEAT, node2.min, node2.max);
+            return true;
         }
       };
       if (!emitNode(body.root)) return void 0;
@@ -6692,6 +7635,33 @@ var Encoder = class {
         return childrenOf(def);
     }
   }
+  /**
+   * THE FIRST-CHARACTER GATE OF AN `optional`, `not` OR `peek` CHILD.
+   *
+   * A non-nullable child cannot match at a character outside its first set, so
+   * the wrapper's outcome there is already decided: `optional` yields `null`,
+   * `not` succeeds, `peek` fails with its own set. The interpreter's `optional`
+   * makes that test itself (`repeat.ts` `startsFirstSet`); the table entered the
+   * child — a rollback mark, the call, the child's own failure — to learn it.
+   *
+   * The gate is an `OP_GATE` row around the child, so every engine runs it
+   * unchanged, a probe or tolerant parse forwards through it as for a node's
+   * gate, and the wrapper's row keeps its layout. The engines test the class
+   * before taking the wrapper's mark. The first set is resolved through
+   * `winners`, the analysis a choice arm's gate uses, so a composed rule's set
+   * is the merged one. A scalar `not` child stays bare: `scalarTerminalNotChild`
+   * already reduces it to one recognizer call.
+   */
+  lookaheadGate(p, child) {
+    const op = this.code[child];
+    if (op === OP_GATE || op === OP_LIT || op === OP_LIT_CI || op === OP_LIT_TRACK || op === OP_LIT_CI_TRACK || op === OP_RX || op === OP_RX_TRACK) return child;
+    const rr = this.refResolver();
+    if (matchesEmpty(p, /* @__PURE__ */ new Set(), rr)) return child;
+    const cls = this.charClass(firstSetOf(p, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
+    if (cls < 0) return child;
+    const e = deriveExpected(p);
+    return this.emit(OP_GATE, cls, child, this.expected(e.length > 0 ? e : [p._tag]));
+  }
   /** A first set becomes a char class string, or −1 for `any`. */
   charClass(fs) {
     if (fs.kind !== "ranges" || fs.ranges.length === 0) return -1;
@@ -6703,12 +7673,19 @@ 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;
+  /**
+   * The first set a node's or an attempt's fail-fast gate tests. A bare
+   * cross-rule ref resolves through `winners` (a compose OVERRIDE may widen
+   * it). Any other body keeps its construction-time `_meta.firstSet`, except
+   * where that is `any`: under `compose()` a body that reaches a rule of
+   * another piece is built before that rule exists, so its cached set is
+   * `any` and the node got NO gate (jess's `CompoundSelector` was entered at
+   * `{`, `Call` at `}`). The resolved set is the one a choice arm's gate uses,
+   * over the final merged map.
+   */
+  gateFirstSet(p) {
+    const cached = p._meta.firstSet;
+    return p._def.tag === "lazy" || cached.kind === "any" ? firstSetOf(p, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : cached;
   }
   /**
    * Wrap one choice arm in its `autoNot` checks (`OP_REJECT`).
@@ -6836,6 +7813,50 @@ var Encoder = class {
     if (!hasOwnTriviaBoundary(target)) return ip;
     return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip);
   }
+  /**
+   * The `OP_RGATE` operands of a choice arm that opens with `routed()`, or
+   * `undefined`. Through `node()`/scope wrappers and first sequence terms, the
+   * arm's next term after the routed token is found; the gate is that term's
+   * first characters, with the trivia in force at the boundary before it, so
+   * the arm is entered only where it can get past the token. The term must be
+   * unable to match empty or to commit, so a miss is exactly that term failing
+   * at the token's end with its own set.
+   */
+  routedArmGate(arm) {
+    const walk = (p, trivia2, depth) => {
+      if (depth > 16) return void 0;
+      const d = p._def;
+      switch (d.tag) {
+        case "routed":
+          return "end";
+        case "node":
+          return walk(d.parser, trivia2, depth + 1);
+        case "grammar":
+          return walk(d.parser, d.clearTrivia === true ? void 0 : d.triviaParser ?? trivia2, depth + 1);
+        case "sequence": {
+          const head = d.parsers[0];
+          if (head === void 0) return void 0;
+          const r = walk(head, trivia2, depth + 1);
+          if (r !== "end") return r;
+          const next2 = d.parsers[1];
+          return next2 === void 0 ? "end" : { next: next2, boundary: trivia2 };
+        }
+        default:
+          return void 0;
+      }
+    };
+    const follow = walk(arm, this.activeTrivia, 0);
+    if (follow === void 0 || follow === "end") return void 0;
+    const rr = this.refResolver();
+    const { next, boundary } = follow;
+    if (matchesEmpty(next, /* @__PURE__ */ new Set(), rr) || mayCommitFailure(next, rr, this.commitFailureMemo)) return void 0;
+    const nextTag = next._def.tag;
+    if (nextTag !== "literal" && nextTag !== "regex" && nextTag !== "keywords" && nextTag !== "label") return void 0;
+    const first = firstSetOf(next, /* @__PURE__ */ new Set(), rr, boundary);
+    const cls = this.charClass(boundary === void 0 ? first : union(first, firstSetOf(boundary, /* @__PURE__ */ new Set(), rr)));
+    if (cls < 0) return void 0;
+    return { cls, fx: this.expected(deriveExpected(next)) };
+  }
   node(p) {
     const lazyRef = p._def.tag === "lazy";
     const scopeKey = lazyRef ? this.activeTrivia : void 0;
@@ -6960,6 +7981,10 @@ var Encoder = class {
         return head;
       }
       case "choice": {
+        if (this.plan === void 0) {
+          const factored = factorSharedEnds(d);
+          if (factored !== void 0) return this.node(factored).ip;
+        }
         if (d.strategy.tag === "greedyClassify") {
           const superIndex = d.strategy.superIndex;
           const sup = this.node(d.parsers[superIndex]).ip;
@@ -6983,9 +8008,12 @@ var Encoder = class {
         const kids = arms.map((c, k) => {
           const src = order[k];
           const checks = d.autoNot[src];
-          const inner = this.node(c).ip;
-          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gate = d.gates[src];
+          const plain2 = (checks === null || checks === void 0 || checks.length === 0) && (gate === null || gate === void 0);
+          const routedGate = plain2 ? this.routedArmGate(c) : void 0;
+          const body = this.node(c).ip;
+          const inner = routedGate === void 0 ? body : this.emit(OP_RGATE, routedGate.cls, body, routedGate.fx);
+          const ip = checks === null || checks === void 0 || checks.length === 0 ? inner : this.reject(inner, checks);
           const gated = gate === null || gate === void 0 ? ip : this.emit(OP_ARMGATE, this.fn(gate, d.gateSrcs?.[src] ?? null), ip, this.expected(deriveExpected(c)));
           return this.covWrap(gated, armCovIds?.[src], 1);
         });
@@ -7013,6 +8041,12 @@ var Encoder = class {
             if (transactionalFirst[i] !== void 0) classes[i] = -1;
           }
         }
+        if (d.gates.some((g) => g !== null && g !== void 0) && !dispatchIsExclusive(classes, this.cc)) {
+          for (let k = 0; k < classes.length; k++) {
+            const gate = d.gates[order[k]];
+            if (gate !== null && gate !== void 0) classes[k] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         let rollbackMask = kids.length > 31 ? -1 : 0;
@@ -7042,7 +8076,7 @@ var Encoder = class {
       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, this.activeTrivia));
+        const itemClass = matchesEmpty(d.parser, /* @__PURE__ */ new Set(), rr) ? -1 : this.charClass(firstSetOf(d.parser, /* @__PURE__ */ new Set(), rr, this.activeTrivia));
         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)), itemClass) : this.emit(op, child, min, d.max ?? -1, -1, 0);
@@ -7066,7 +8100,7 @@ var Encoder = class {
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep, flags);
       }
       case "optional": {
-        const head = this.emit(OP_OPT, this.node(d.parser).ip);
+        const head = this.emit(OP_OPT, this.lookaheadGate(d.parser, this.node(d.parser).ip));
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(head);
         return head;
       }
@@ -7114,8 +8148,8 @@ var Encoder = class {
           // every CST node, so this is load-bearing, not reflection trivia.
           d.tags === void 0 ? -1 : this.constant(d.tags)
         );
-        if (matchesEmpty(d.parser)) return body;
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
+        if (matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return body;
+        const fs = this.gateFirstSet(d.parser);
         if (fs.kind === "any") return body;
         const cls = this.charClass(fs);
         if (cls < 0) return body;
@@ -7207,7 +8241,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(assertionFailureExpected(false, d.parser._tag)));
+        return this.emit(OP_NOT, this.lookaheadGate(d.parser, 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":
@@ -7228,14 +8262,14 @@ 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(assertionFailureExpected(true, d.parser._tag)));
+        return this.emit(OP_PEEK, this.lookaheadGate(d.parser, 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": {
         const inner = this.emit(OP_ATTEMPT, this.node(d.parser).ip, d.contain === true ? 1 : 0);
         if (!this.failureNeedsRollback(d.parser, void 0)) this.failureRollbackCleanSites.add(inner);
-        const fs = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
-        if (fs.kind === "any" || matchesEmpty(d.parser)) return inner;
+        const fs = this.gateFirstSet(d.parser);
+        if (fs.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs);
         if (cls < 0) return inner;
         const e = deriveExpected(d.parser);
@@ -7303,6 +8337,7 @@ var Encoder = class {
     const slots = (ip) => {
       switch (this.code[ip]) {
         case OP_GATE:
+        case OP_RGATE:
           return [ip + 2];
         case OP_RULE:
         case OP_OPT:
@@ -8530,6 +9565,7 @@ function childSlots(code, ip, out) {
     case OP_LEAF:
     case OP_SOURCE_LEAF:
     case OP_ARMGATE:
+    case OP_RGATE:
       out.push(code[ip + 2]);
       return true;
     // `ROUTED fallback` — the operand is an offset or −1. The routed token itself is
@@ -8613,6 +9649,42 @@ function reachableSites(code, roots) {
   }
   return seen;
 }
+function passCollapse(code, ip, hostCst) {
+  const flags = code[ip + 3];
+  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return false;
+  if (flags !== 32 && flags !== 34) return false;
+  let at = code[ip + 2];
+  for (let n = 0; n < 8; n++) {
+    const op = code[at];
+    if (op === OP_GATE || op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[at + 3] === 0) at = code[at + 2];
+    else if (op === OP_RULE) at = code[at + 1];
+    else break;
+  }
+  return code[at] === OP_NODE;
+}
+function gatedPassCollapse(code, ip, hostCst) {
+  const flags = code[ip + 3];
+  if (hostCst || code[ip] !== OP_NODE || code[ip + 1] < 0 || code[ip + 4] >= 0) return void 0;
+  if (flags !== 32 && flags !== 34) return void 0;
+  const seq = code[ip + 2];
+  if (code[seq] !== OP_SEQ && code[seq] !== OP_SEQV) return void 0;
+  const n = code[seq + 1];
+  if (n < 2) return void 0;
+  const leads = [];
+  const lits = [];
+  for (let i = 0; i < n - 1; i++) {
+    const t2 = code[seq + 2 + i];
+    if (code[t2] !== OP_OPT && code[t2] !== OP_NOT) return void 0;
+    const g = code[t2 + 1];
+    if (code[g] === OP_GATE) leads.push(g);
+    else if (code[g] === OP_LIT) lits.push(code[g + 1]);
+    else return void 0;
+  }
+  const last = code[seq + 2 + n - 1];
+  let at = last;
+  for (let k = 0; k < 8 && (code[at] === OP_GATE || code[at] === OP_RULE); k++) at = code[at] === OP_RULE ? code[at + 1] : code[at + 2];
+  return code[at] === OP_NODE ? { leads, lits, last } : void 0;
+}
 function transfer(code, ip, at, hostCst) {
   const op = code[ip];
   if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
@@ -8624,14 +9696,18 @@ function transfer(code, ip, at, hostCst) {
   }
   if (op === OP_NODE || op === OP_NODE_TRACK) {
     const flags = code[ip + 3];
+    if (passCollapse(code, ip, hostCst)) return at;
+    const gated = gatedPassCollapse(code, ip, hostCst) !== void 0;
     const directChildren = !hostCst && op === OP_NODE && code[ip + 1] >= 0 && code[ip + 4] < 0 && ((flags & ~128) === 2 || flags === 18 || flags === 34);
     if (directChildren) {
-      return { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
+      const framed2 = { tri: at.tri, buf: false, raw: RAW_UNKNOWN, cap: CAP_OFF };
+      return gated ? meet(at, framed2) : framed2;
     }
     const cap = (flags & 4) !== 0 || hostCst ? CAP_ON : CAP_OFF;
     const raw = !hostCst && code[ip + 1] >= 0 && code[ip + 4] < 0 && (flags & 2) !== 0 ? RAW_OMIT : RAW_CAPTURE;
     if (at.buf && raw === at.raw && cap === at.cap) return at;
-    return { tri: at.tri, buf: true, raw, cap };
+    const framed = { tri: at.tri, buf: true, raw, cap };
+    return gated ? meet(at, framed) : framed;
   }
   if (op === OP_TOKEN) {
     if (at.tri === TRI_NONE && !at.buf) return at;
@@ -8669,6 +9745,40 @@ function computeSiteLabels(code, roots, hostCst) {
   }
   return { at: (ip) => labels.get(ip) ?? TOP };
 }
+function scopeIsIdentity(code, ip, at) {
+  const op = code[ip];
+  if (op !== OP_SCOPE_PLAIN && !(op === OP_SCOPE && code[ip + 3] === 0)) return false;
+  const ki = code[ip + 1];
+  return at.tri === (ki < 0 ? TRI_NONE : ki);
+}
+function scanHandoffNeeded(code, ip, labels) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [ip];
+  const kids = [];
+  while (stack.length > 0) {
+    const at = stack.pop();
+    if (seen.has(at)) continue;
+    seen.add(at);
+    const l = labels.at(at);
+    if (l.tri === TRI_UNKNOWN) return true;
+    const op = code[at];
+    if (op === OP_SCAN) return true;
+    if (op === OP_TOKEN || op === OP_SCOPE_CAP) continue;
+    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE) && !(code[at + 1] >= 0 && l.tri === code[at + 1] && (op === OP_SCOPE_PLAIN || code[at + 3] === 0))) continue;
+    kids.length = 0;
+    if (!childSlots(code, at, kids)) return true;
+    for (const c of kids) stack.push(c);
+  }
+  return false;
+}
+function triviaLeadRanges(tri, trivia2) {
+  if (tri === TRI_NONE) return [];
+  if (tri < 0) return void 0;
+  const fs = trivia2[tri]?._meta.firstSet;
+  if (fs === void 0) return void 0;
+  if (fs.kind === "empty") return [];
+  return fs.kind === "ranges" && fs.ranges !== void 0 ? fs.ranges : void 0;
+}
 
 // src/table/scalar-terminal.ts
 function makeScalarRecognizer(op, spec) {
@@ -8706,6 +9816,12 @@ function scalarTerminalNotChild(code, ip) {
   const op = code[child];
   return op === OP_RX || op === OP_LIT ? child : -1;
 }
+function scalarTerminalPeekChild(code, ip) {
+  if (code[ip] !== OP_PEEK) return -1;
+  const child = code[ip + 1];
+  const op = code[child];
+  return op === OP_RX || op === OP_LIT ? child : -1;
+}
 function leadingScalarTerminal(code, ip, minDepth = 2, throughAttempt = true, throughPeek = false) {
   const seen = /* @__PURE__ */ new Set();
   let at = ip;
@@ -8883,6 +9999,59 @@ function leadingTriviaFieldAt(code, k, ip) {
   return code[ip] === OP_FIELD && (fieldSpec(k[code[ip + 1]]).bits & FIELD_LEADING_TRIVIA) !== 0;
 }
 
+// src/table/hold-gap.ts
+var WRAPPERS = /* @__PURE__ */ new Set([
+  OP_NODE,
+  OP_XFORM,
+  OP_LEAF,
+  OP_SOURCE_LEAF,
+  OP_TOKEN,
+  OP_SCOPE,
+  OP_SCOPE_CAP,
+  OP_SCOPE_PLAIN,
+  OP_FIELD,
+  OP_LABEL,
+  OP_EXPECT,
+  OP_WITHCTX,
+  OP_RULE,
+  OP_ATTEMPT,
+  OP_COV
+]);
+function rowNullable(code, k, ip, memo) {
+  const hit = memo.get(ip);
+  if (hit !== void 0) return hit;
+  memo.set(ip, true);
+  const op = code[ip];
+  const kids = [];
+  let out = true;
+  if (op === OP_GATE) out = false;
+  else if (op === OP_LIT || op === OP_LIT_CI) out = k[code[ip + 1]].length === 0;
+  else if (op === OP_RX) {
+    const re = k[code[ip + 1]];
+    out = !(re instanceof RegExp) || regexCanMatchEmpty(re.source);
+  } else if (op === OP_SEQ || op === OP_SEQV || op === OP_SEQX) {
+    childSlots(code, ip, kids);
+    out = kids.every((c) => rowNullable(code, k, c, memo));
+  } else if (op === OP_CHOICE) {
+    childSlots(code, ip, kids);
+    out = kids.length === 0 || kids.some((c) => rowNullable(code, k, c, memo));
+  } else if (op === OP_REP || op === OP_REPV) {
+    out = code[ip + 2] === 0 || rowNullable(code, k, code[ip + 1], memo);
+  } else if (WRAPPERS.has(op)) {
+    if (childSlots(code, ip, kids) && kids.length === 1) out = rowNullable(code, k, kids[0], memo);
+  }
+  memo.set(ip, out);
+  return out;
+}
+function holdsGap(code, k, base, n, i, memo) {
+  if (i < 1 || i + 1 >= n) return false;
+  const term = code[base + i];
+  if (code[term] !== OP_NOT && code[term] !== OP_PEEK) return false;
+  const next = code[base + i + 1];
+  if (code[next] === OP_ADJ || leadingTriviaFieldAt(code, k, next)) return false;
+  return !rowNullable(code, k, next, memo);
+}
+
 // src/table/emit-assembly.ts
 var Unemittable = class extends Error {
   construct;
@@ -8960,7 +10129,13 @@ var EMITTED_PARAMS = [
   // Appended for trivia-attributing fields (`field(…, { leadingTrivia })`);
   // old factories ignore them.
   "LEAD",
-  "triviaFieldCapture"
+  "triviaFieldCapture",
+  // Appended for the deferred-commit trivia skip (`trivia-gap.ts`); old
+  // factories ignore it.
+  "skipDeferredTrivia",
+  // Appended for the pass-through collapse (`run-support.ts`); old factories
+  // ignore it.
+  "collapseEmpty"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -8981,7 +10156,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))return commitTriviaScan(scanTriviaCompact(input,cur,ctx))
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)
 }
 function _pushLeaf(ctx,value,s,e){pushCstLeaf(ctx,{_tag:'leaf',value,span:{start:s,end:e}})}
@@ -9157,6 +10332,24 @@ ${fast}
 ${scanned}
 }`;
 }
+function emitHoldTerm(callee, dst, t2, l, skip) {
+  const fast = `const ${t2}v=${callee}(input,cur,ctx)
+if(${t2}v===FAIL)return FAIL
+${dst}=${t2}v
+cur=EC.e`;
+  if (l.tri === TRI_NONE) return fast;
+  const held = `const ${t2}s=${skip}(input,cur,ctx)
+const ${t2}v=${callee}(input,${t2}s,ctx)
+if(${t2}v===FAIL)return FAIL
+${dst}=${t2}v
+cur=${t2}s`;
+  if (l.tri !== TRI_UNKNOWN) return held;
+  return `if(ctx.trivia===undefined){
+${fast}
+}else{
+${held}
+}`;
+}
 function leadSkip(hasTrivia, leadTrivia, skip) {
   if (hasTrivia === "false") return "{}";
   const call = `itemStart=${skip}(input,itemStart,ctx)`;
@@ -9188,7 +10381,7 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
+function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false, select) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t2;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
@@ -9198,6 +10391,7 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
   const reachable = [...reachableSites(code, roots)];
   const labels = computeSiteLabels(code, roots, hostCst);
   const scalarSpecs = /* @__PURE__ */ new Set();
+  const nullable2 = /* @__PURE__ */ new Map();
   const largeChoiceScalarSpecs = /* @__PURE__ */ new Set();
   const largeChoiceLiteralFamilies = /* @__PURE__ */ new Map();
   const largeChoiceScalarSequences = /* @__PURE__ */ new Map();
@@ -9287,6 +10481,8 @@ function emitAssemblySource(t2, prog, cfg, extraIps = [], staticBuild = false) {
   };
   const bodies = [];
   const byIp = /* @__PURE__ */ new Map();
+  const externals = [];
+  const siteBytes = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   const prelude = [];
   const skipDefs = [];
@@ -9422,6 +10618,18 @@ return 1
     tokenDecisionRefs.set(dispatchIp, made);
     return made;
   }
+  function gateMissTest(gip) {
+    const resolved = t2.cc[code[gip + 1]];
+    const ci = classes.push([resolved]) - 1;
+    classPlan.push([code[gip + 1]]);
+    const cls = hoist("cl", `CLS[${ci}][0]`);
+    return isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`;
+  }
+  function lookaheadMiss(child, miss) {
+    if (code[child] !== OP_GATE || cfg.tolerant || cfg.probe) return "";
+    return `if(${gateMissTest(child)}){${miss}}
+`;
+  }
   function skipFor(l) {
     if (l.tri < 0) return "_skipTrivia";
     const ki = l.tri;
@@ -9432,8 +10640,8 @@ return 1
     const nm = `_sk${skipPool.size}`;
     skipPool.set(key, nm);
     if (!hasScan) {
-      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))
+      skipDefs.push(l.buf ? `function ${nm}(input,cur,ctx){return skipDeferredTrivia(input,cur,ctx)}` : `function ${nm}(input,cur,ctx){
+if(needsDeferredTriviaCommit(ctx))return skipDeferredTrivia(input,cur,ctx)
 return advanceTrivia(input,cur,ctx)}`);
       return nm;
     }
@@ -9478,9 +10686,17 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const target = resolveAlias(ip);
     const done = byIp.get(target);
     if (done !== void 0) return done;
+    if (select !== void 0 && !select.has(target)) {
+      const ext = `_px${target}`;
+      byIp.set(target, ext);
+      externals.push(target);
+      return ext;
+    }
     const fname = `_pf${target}`;
     byIp.set(target, fname);
-    bodies.push(lower(target, fname));
+    const body = lower(target, fname);
+    siteBytes.set(target, body.length);
+    bodies.push(body);
     return fname;
   }
   function resolveAlias(ip) {
@@ -9500,9 +10716,7 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const op = code[ip];
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
     if (op === OP_RULE) return code[ip + 1];
-    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && labels.at(ip).tri === code[ip + 1]) {
-      return code[ip + 2];
-    }
+    if (scopeIsIdentity(code, ip, labels.at(ip))) return code[ip + 2];
     return void 0;
   }
   function lower(ip, fname) {
@@ -9620,14 +10834,44 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}EC.e=pos;return ''}`;
       case OP_GATE: {
         const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+if(${gateMissTest(ip)}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_RGATE: {
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return `${head}
+return ${child}(input,pos,ctx)
+}`;
         const resolved = t2.cc[code[ip + 1]];
         const ci = classes.push([resolved]) - 1;
         classPlan.push([code[ip + 1]]);
         const cls = hoist("cl", `CLS[${ci}][0]`);
         const xf = fxRef(code[ip + 3]);
         return `${head}
-if(${staticBuild && isAsciiOnlyClass(resolved) ? `${cls}.ascii[input.charCodeAt(pos)]!==1` : `!classHas(${cls},lead(input,pos))`}){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+const it=ctx._routed
+if(it!==undefined&&it.span.start===pos&&!classHas(${cls},lead(input,it.span.end))){ctx._fe=it.span.end;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_ARMGATE: {
+        const pred = fnRef(code[ip + 1]);
+        const child = link(code[ip + 2]);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+if(!${pred}(ctx.state)){ctx._fc=false;ctx._fe=-1;ctx._fx=${xf};return FAIL}
 return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_WITHCTX: {
+        const ki = code[ip + 1];
+        const child = link(code[ip + 2]);
+        return `${head}
+const saved=ctx.state
+ctx.state=${ki < 0 ? `${fnRef(~ki)}(saved)` : kRef(ki)}
+try{return ${child}(input,pos,ctx)}finally{ctx.state=saved}
 }`;
       }
       case OP_XFORM: {
@@ -9883,24 +11127,34 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){EC.e=pos;return null}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){EC.e=pos;return null}
 ctx._fe=pos
 ctx._fx=${xf}
 return FAIL
 }`;
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = recognizerRef(code[scalarChild + 1]);
+          const xf2 = fxRef(code[ip + 2]);
+          return `${head}
+if(${recognize}(input,pos)<0){ctx._fe=pos;ctx._fx=${xf2};return FAIL}
+EC.e=pos
+return null
+}`;
+        }
         const child = link(code[ip + 1]);
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
-const v=${child}(input,pos,ctx)
+${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
+${cfg.probe ? "const pb=ctx._probe?.best\n" : ""}const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
-if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+${cfg.probe ? "if(ctx._probe!==undefined)ctx._probe.best=pb??null\n" : ""}if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
 EC.e=pos
 return null
 }`;
@@ -9910,7 +11164,7 @@ return null
         const clean = !REC && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
-${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
 ctx._fc=false
 const v=${child}(input,pos,ctx)
 if(v===FAIL){
@@ -9971,7 +11225,7 @@ return v
             );
           } else {
             const callee = leadingTriviaFieldAt(code, k, childIp) ? `(LEAD.at=cur,${kids[i]})` : kids[i];
-            parts.push(emitTerm(callee, vn, tmp(), L, skipFor(L)));
+            parts.push(holdsGap(code, k, base, n, i, nullable2) ? emitHoldTerm(callee, vn, tmp(), L, skipFor(L)) : emitTerm(callee, vn, tmp(), L, skipFor(L)));
           }
           names.push(vn);
         }
@@ -9991,7 +11245,7 @@ return v
           const asc = hoist("as", `DISP[${di}].ascii`);
           const hiArr = table.hi;
           const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join("\n");
-          const directAscii = staticBuild && table.hi.length === 0;
+          const directAscii = table.hi.length === 0;
           return `${head}
 const c=${directAscii ? "input.charCodeAt(pos)" : "lead(input,pos)"}
 let arm=-1
@@ -10018,7 +11272,7 @@ return FAIL
           const expected = Array.from({ length: n }, (_, i) => fxRef(code[base + n + i]));
           const gates = Array.from({ length: n }, (_, i) => table.armCls[i] ?? null);
           const maskable = n <= 32;
-          const directAsciiMask = staticBuild && maskable && gates.every(isAsciiOnlyClass);
+          const directAsciiMask = maskable && gates.every(isAsciiOnlyClass);
           const gateRefs = directAsciiMask ? [] : Array.from({ length: n }, (_, i) => hoist("g", `DISP[${di}].armCls[${i}]`));
           const tokenCandidate = tokenChoiceCandidates.get(ip);
           const pretests = Array.from({ length: n }, (_, i) => {
@@ -10060,7 +11314,7 @@ return FAIL
           if (choiceCannotCommit(prog, ip) && !startFailureExact) {
             const deepAt = Array.from({ length: n }, () => tmp());
             const deepFx = Array.from({ length: n }, () => tmp());
-            const remember = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
+            const remember2 = (i, at, expectedSet) => `${deepAt[i]}=${at};${deepFx[i]}=${expectedSet}`;
             const lazyArms = (ascii) => arms.map((arm, i) => {
               const pretest = pretests[i];
               const decision = pretest?.token === void 0 && pretest?.sequence === void 0 ? "" : tmp();
@@ -10072,13 +11326,13 @@ return FAIL
 if(${decision}===0){
 ctx._fc=false
 {const at=_pfTokEnd
-${remember(i, "at", pretest.token.expected)}}
+${remember2(i, "at", pretest.token.expected)}}
 }`;
               const sequenceMiss = pretest?.sequence === void 0 ? "" : `
 else if(${ascii ? `(bits&${1 << i})!==0&&` : ""}${decision}<0){
 ctx._fc=false
 {const at=_pfSeqEnd
-${remember(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
+${remember2(i, "at", pretest.sequence.expected.map((value, at) => `${decision}===${~at}?${value}:`).join("") + pretest.sequence.expected.at(-1))}}
 }`;
               return `${decision === "" ? "" : `let ${decision}=${pretest?.sequence === void 0 ? -1 : 0}
 `}if(${gate}){
@@ -10086,7 +11340,7 @@ ctx._fc=false
 {const v=${arm}(input,pos,ctx)
 if(v!==FAIL)return v}
 {const at=ctx._fe??pos
-${remember(i, "at", "ctx._fx")}}
+${remember2(i, "at", "ctx._fx")}}
 ${rollbackFor(i)}
 }${routeMiss}${sequenceMiss}`;
             }).join("\n");
@@ -10199,7 +11453,7 @@ const bits=${maskName}[${directAsciiMask ? "c" : "c<0?128:c"}]
 if(bits===0){ctx._fe=pos;ctx._fx=${choiceFx};return FAIL}
 ${startFailureExact ? "" : "let prev=0"}
 ${maskArms}
-${startFailureExact ? "" : `if(best===pos)acc=${catchName}(${n},prev,acc)`}
+${startFailureExact ? "" : `if(best===pos&&prev!==0)acc=${catchName}(${n},prev,acc)`}
 ctx._fe=pos;ctx._fx=${startFailureExact ? `best===pos?${choiceFx}:acc??${choiceFx}` : `acc??${choiceFx}`}
 return FAIL
 }
@@ -10298,7 +11552,7 @@ return [key,v]
             const ci = classes.push([resolved]) - 1;
             classPlan.push([itemClassIndex]);
             itemCls = hoist("ri", `CLS[${ci}][0]`);
-            itemAscii = staticBuild && isAsciiOnlyClass(resolved);
+            itemAscii = isAsciiOnlyClass(resolved);
           }
         }
         const itemMiss = (at) => itemAscii ? `${itemCls}.ascii[input.charCodeAt(${at})]!==1` : `!classHas(${itemCls},lead(input,${at}))`;
@@ -10454,6 +11708,26 @@ return nd
         const trailingTrivia = (flags & 128) !== 0;
         const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
         const leanFlags = flags & ~128;
+        if (build !== void 0 && passCollapse(code, ip, hostCst)) {
+          return `${head}
+const v=${child}(input,pos,ctx)
+if(v!==undefined)return v
+return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
+}`;
+        }
+        const gated = build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
+        const triviaLead = gated === void 0 ? void 0 : triviaLeadRanges(labels.at(code[ip + 2]).tri, t2.trivia);
+        const gp = gated !== void 0 && triviaLead !== void 0 && triviaLead.length <= 16 ? `const gc=lead(input,pos)
+if(!(${[
+          ...gated.leads.map((g) => `!(${gateMissTest(g)})`),
+          ...gated.lits.map((i) => `gc===${k[i].codePointAt(0)}`),
+          ...triviaLead.map((r) => r.lo === r.hi ? `gc===${r.lo}` : `(gc>=${r.lo}&&gc<=${r.hi})`)
+        ].join("||") || "false"})){
+const gv=${link(gated.last)}(input,pos,ctx)
+if(gv!==undefined)return gv
+return collapseEmpty(ctx,${build},input,pos,EC.e,${flags === 32})
+}
+` : "";
         if (!hostCst && !tracked && build !== void 0 && proj < 0 && (leanFlags === 2 || (flags === 18 || flags === 34))) {
           const fields = flags === 18;
           const collapseChildren = flags === 34;
@@ -10488,7 +11762,7 @@ 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
+${gp}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
@@ -10524,7 +11798,7 @@ return nd
         const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
         const omitsRaw = !hostCst && build !== void 0 && proj < 0 && (flags & 2) !== 0;
         const ty = q(type);
-        const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
+        const stArg = "ctx.state";
         const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
         let value;
         if (proj >= 0) {
@@ -10563,7 +11837,7 @@ const hostKids=kids
 const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
 const tlog=buf.tl??EMPTY_TLOG`;
         return `${head}
-const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+${!hostCst && !tracked ? gp : ""}const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
 const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
 ${openCapture}
 ctx.captureTrivia=${captureWide}
@@ -10585,7 +11859,7 @@ ctx.captureTrivia=sCap
 if(v===FAIL)return FAIL
 const end=EC.e
 const span=${tracked ? "spanLines(ctx,pos,end)" : "{start:pos,end}"}
-const st=${readsState ? "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)" : "undefined"}
+const st=${readsState ? "ctx.state" : "undefined"}
 let nd
 ${unwrap ? "if(kids.length===1)nd=unwrapChild(kids[0])\nelse " : ""}${collapse ? "if(kids.length===1)nd=kids[0]\nelse " : ""}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
 else ` : ""}{${value}}
@@ -10598,21 +11872,57 @@ return nd
         throw new Unemittable(`OP_${OP_NAMES[op] ?? String(op)}`);
     }
   }
+  const served = (ip) => select === void 0 || select.has(resolveAlias(ip));
   const ruleEntries = [];
   for (const [rname, entryIp] of Object.entries(prog.rules)) {
+    if (!served(entryIp)) continue;
     const target = link(entryIp);
     const rn = `_r_${rname.replace(/[^A-Za-z0-9_$]/g, "_")}`;
     bodies.push(`const ${rn}=${target}`);
     ruleEntries.push(`${q(rname)}:${rn}`);
   }
   const extra = [];
-  for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`);
+  const exported = /* @__PURE__ */ new Set();
+  for (const ip of extraIps) {
+    if (!served(ip)) continue;
+    exported.add(ip);
+    extra.push(`${ip}:${link(ip)}`);
+  }
+  if (select !== void 0) {
+    const kids = [];
+    for (const ip of reachable) {
+      if (select.has(resolveAlias(ip))) continue;
+      kids.length = 0;
+      childSlots(code, ip, kids);
+      for (const kid of kids) {
+        const target = resolveAlias(kid);
+        if (!select.has(target) || exported.has(target)) continue;
+        exported.add(target);
+        extra.push(`${target}:${link(target)}`);
+      }
+    }
+  }
+  const hybrid = select === void 0 ? "" : `,
+ext:[${externals.join(",")}],
+bind:function(xs,ps){_xScan=xs
+${externals.map((ip, i) => `_xp${ip}=ps[${i}]`).join("\n")}},
+scan:function(s){const o=_pfScan;_pfScan=s;return o}`;
+  const scannerFor = (ip) => {
+    const ki = labels.at(ip).tri;
+    if (ki === TRI_UNKNOWN) return "_pfScan";
+    if (ki === TRI_NONE) return "null";
+    return swapLegal && !triviaLabelled[ki] && t2.triviaScan[ki] != null ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
+  };
+  const externalDefs = select === void 0 ? "" : `let _xScan
+${externals.map((ip) => `let _xp${ip}
+function _px${ip}(input,pos,ctx){const o=_xScan(${scannerFor(ip)});const v=_xp${ip}(input,pos,ctx);_xScan(o);return v}`).join("\n")}
+`;
   const source = `${RUNTIME_PRELUDE}${needsNoRawPrelude ? NO_RAW_RUNTIME_PRELUDE : ""}
 ${prelude.join("\n")}
 ${skipDefs.join("\n")}
 ${choiceDefs.join("\n")}
 ${bodies.join("\n")}
-function _begin(ctx){
+${externalDefs}function _begin(ctx){
 const host=ctx.build
 if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
 _pfDepth++
@@ -10639,7 +11949,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -10647,6 +11957,7 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
@@ -10897,157 +12208,27 @@ function literal(value, opts = {}) {
         return { ok: true, value, span };
       }
       return failAt(ctx, expected, pos);
-    };
-  })() : function parse3(input, pos, ctx) {
-    const end = pos + value.length;
-    if (end > input.length) {
-      return failAt(ctx, expected, pos);
-    }
-    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
-    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
-      const span = { start: pos, end };
-      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
-      return { ok: true, value: matchedValue, span };
-    }
-    return failAt(ctx, expected, pos);
-  };
-  return {
-    _tag: "literal",
-    _meta: meta,
-    _def: { tag: "literal", value, caseInsensitive },
-    _parseScalar: parseScalar,
-    parse: parse2
-  };
-}
-
-// src/combinators/sequence.ts
-function sequence(...parsers) {
-  let adjacency = null;
-  for (let i = 0; i < parsers.length; i++) {
-    const a = adjacencyOf(parsers[i]);
-    if (a === null) continue;
-    if (i === 0) {
-      throw new TypeError(
-        `sequence(): ${a.polarity}() cannot be the FIRST term \u2014 an adjacency assertion tests the gap after the PRECEDING term. Put a concrete term first.`
-      );
-    }
-    ;
-    (adjacency ??= Array.from({ length: parsers.length }, () => null))[i] = a;
-  }
-  const hasAdjacency = adjacency !== null;
-  let leading = null;
-  for (let i = 1; i < parsers.length; i++) {
-    if (leadsTrivia(parsers[i])) (leading ??= Array.from({ length: parsers.length }, () => false))[i] = true;
-  }
-  const strictArity = !hasAdjacency && (parsers.length === 2 && !matchesEmpty(parsers[1]) || parsers.length === 3 && parsers.every((p) => !matchesEmpty(p))) ? parsers.length : 0;
-  const meta = {
-    // Union through the nullable prefix — a leading optional()/many() lets a later
-    // term's first char start the sequence. Just `parsers[0]` under-approximates.
-    firstSet: sequenceFirstSet(parsers),
-    canMatchNewline: parsers.some((p) => p._meta.canMatchNewline),
-    isTrivia: false
-  };
-  const def = { tag: "sequence", parsers };
-  const scalarParsers = parsers.map(scalarOf);
-  const parseScalar = (input, pos, ctx) => {
-    let cur = pos;
-    if (strictArity !== 0) {
-      cur = scalarParsers[0](input, cur, ctx);
-      if (cur < 0) return cur;
-      const first = ctx._sv;
-      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
-      cur = scalarParsers[1](input, cur, ctx);
-      if (cur < 0) return cur;
-      const second = ctx._sv;
-      if (strictArity === 2) {
-        ctx._sv = def.valueUnused ? void 0 : [first, second];
-        return cur;
-      }
-      if (ctx.trivia) cur = advanceTrivia(input, cur, ctx);
-      cur = scalarParsers[2](input, cur, ctx);
-      if (cur < 0) return cur;
-      ctx._sv = def.valueUnused ? void 0 : [first, second, ctx._sv];
-      return cur;
-    }
-    const values = def.valueUnused ? void 0 : [];
-    for (let i = 0; i < scalarParsers.length; i++) {
-      let termPos = cur;
-      if (i > 0 && ctx.trivia) termPos = advanceTrivia(input, cur, ctx);
-      const end = scalarParsers[i](input, termPos, ctx);
-      if (end < 0) return end;
-      if (values !== void 0) values.push(ctx._sv);
-      if (end > termPos || termPos === cur) cur = end;
-    }
-    ctx._sv = values;
-    return cur;
-  };
-  let followSentinels;
-  return {
-    _tag: "sequence",
-    _meta: meta,
-    _def: def,
-    _parseScalar: hasAdjacency || leading !== null ? void 0 : parseScalar,
-    parse(input, pos, ctx) {
-      const tolerant = ctx._tolerant === true;
-      if (tolerant) {
-        followSentinels ??= parsers.map((_, i) => firstSetSentinel(
-          parsers.slice(i + 1).reduce(
-            (set, parser2) => union(set, firstSetOf(parser2)),
-            { kind: "empty" }
-          )
-        ));
-      }
-      const inheritedSync = ctx._sync;
-      const deferredTrivia = needsDeferredTriviaCommit(ctx);
-      const values = def.valueUnused ? void 0 : [];
-      let cur = pos;
-      try {
-        for (let i = 0; i < parsers.length; i++) {
-          if (tolerant) ctx._sync = followSentinels[i] ?? inheritedSync;
-          const assertion = adjacency?.[i];
-          if (assertion) {
-            if (!holdsAdjacency(input, cur, ctx, assertion)) return adjacencyFail(cur, assertion);
-            if (values !== void 0) values.push(null);
-            continue;
-          }
-          let termPos = cur;
-          const markTlog = deferredTrivia ? cstTlLen(ctx) : 0;
-          const markLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
-          const markRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
-          if (ctx.trivia && i > 0) {
-            termPos = deferredTrivia ? commitTriviaScan(scanTriviaCompact(input, cur, ctx)) : advanceTrivia(input, cur, ctx);
-          }
-          const scanTlog = deferredTrivia ? cstTlLen(ctx) : 0;
-          const scanLog = deferredTrivia ? ctx._triviaLog?.length ?? 0 : 0;
-          const scanRootLog = deferredTrivia ? ctx._rootTriviaLog?.length ?? 0 : 0;
-          if (leading?.[i] === true) LEAD.at = cur;
-          const result = parsers[i].parse(input, termPos, ctx);
-          if (!result.ok) return result;
-          if (values !== void 0) values.push(result.value);
-          if (result.span.end > termPos || termPos === cur) cur = result.span.end;
-          else if (deferredTrivia) {
-            rollbackScannedTriviaAt(
-              ctx,
-              markTlog,
-              scanTlog,
-              markLog,
-              scanLog,
-              markRootLog,
-              scanRootLog
-            );
-          }
-        }
-      } finally {
-        if (tolerant) ctx._sync = inheritedSync;
-      }
-      return {
-        ok: true,
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        value: values ?? void 0,
-        span: { start: pos, end: cur }
-      };
+    };
+  })() : function parse3(input, pos, ctx) {
+    const end = pos + value.length;
+    if (end > input.length) {
+      return failAt(ctx, expected, pos);
+    }
+    const matchedValue = caseInsensitive ? input.slice(pos, end) : value;
+    if (caseInsensitive ? asciiFoldEq(matchedValue, value) : input.startsWith(value, pos)) {
+      const span = { start: pos, end };
+      if (canMatchNewline && ctx.trackLines) recordLineRangeFromContext(ctx, input, pos, end);
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value: matchedValue, span });
+      return { ok: true, value: matchedValue, span };
     }
+    return failAt(ctx, expected, pos);
+  };
+  return {
+    _tag: "literal",
+    _meta: meta,
+    _def: { tag: "literal", value, caseInsensitive },
+    _parseScalar: parseScalar,
+    parse: parse2
   };
 }
 
@@ -11118,124 +12299,6 @@ function ref() {
   return slot;
 }
 
-// src/combinators/token.ts
-function semanticLeafValue(_ctx, _input, _start, _end, value) {
-  return value;
-}
-function sourceLeafValue(ctx, input, start, end, value) {
-  return cstOutputHost(ctx.build) ? input.slice(start, end) : value;
-}
-function token(root) {
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "token",
-    _meta: meta,
-    _def: { tag: "token", parser: root },
-    parse(input, pos, ctx) {
-      const savedTrivia = ctx.trivia;
-      const savedKinds = ctx.triviaKindLabels;
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const savedRootTriviaLog = ctx._rootTriviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      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 result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx.trivia = savedTrivia;
-        ctx.triviaKindLabels = savedKinds;
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-        ctx._rootTriviaLog = savedRootTriviaLog;
-      }
-      if (!result.ok) return result;
-      const span = result.span;
-      const value = input.slice(pos, span.end);
-      if (wasCapturing) pushCstLeaf(ctx, { _tag: "leaf", value, span });
-      return { ok: true, value, span };
-    }
-  };
-}
-function makeLeaf(root, fn, sourceCstValue) {
-  const cstValue = sourceCstValue ? sourceLeafValue : semanticLeafValue;
-  const meta = {
-    firstSet: root._meta.firstSet,
-    canMatchNewline: root._meta.canMatchNewline,
-    isTrivia: false
-  };
-  return {
-    _tag: "leaf",
-    _meta: meta,
-    _def: {
-      tag: "leaf",
-      parser: root,
-      fn,
-      ...sourceCstValue ? { cstValue: "source" } : {}
-    },
-    parse(input, pos, ctx) {
-      const savedBuf = ctx._cstBuf;
-      const savedChildren = ctx._cstChildren;
-      const savedLeaves = ctx._cstLeaves;
-      const savedRaw = ctx._cstRawChildren;
-      const savedTriviaLog = ctx._cstTriviaLog;
-      const savedOuterTriviaLog = ctx._triviaLog;
-      const wasCapturing = cstCaptureActive(ctx);
-      ctx._cstBuf = void 0;
-      ctx._cstChildren = void 0;
-      ctx._cstLeaves = void 0;
-      ctx._cstRawChildren = void 0;
-      ctx._cstTriviaLog = void 0;
-      ctx._triviaLog = void 0;
-      let result;
-      try {
-        result = root.parse(input, pos, ctx);
-      } finally {
-        ctx._cstBuf = savedBuf;
-        ctx._cstChildren = savedChildren;
-        ctx._cstLeaves = savedLeaves;
-        ctx._cstRawChildren = savedRaw;
-        ctx._cstTriviaLog = savedTriviaLog;
-        ctx._triviaLog = savedOuterTriviaLog;
-      }
-      if (!result.ok) return result;
-      const value = fn(result.value, result.span);
-      if (wasCapturing) pushCstLeaf(ctx, {
-        _tag: "leaf",
-        value: cstValue(ctx, input, pos, result.span.end, value),
-        span: result.span
-      });
-      return { ok: true, value, span: result.span };
-    }
-  };
-}
-function leaf(root, fn) {
-  return makeLeaf(root, fn, false);
-}
-function sourceLeaf(root, fn) {
-  return makeLeaf(root, fn, true);
-}
-
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
   if (raw) return [];
@@ -11480,37 +12543,184 @@ function escapeClassChar(ch2) {
   return ch2.replace(/[\\\]^-]/g, "\\$&");
 }
 
-// src/table/run-support.ts
-function lineCol(ctx, offset) {
-  const starts = ctx._lineStarts ?? [0];
-  let lo = 0, hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
+// src/table/trivia-gap.ts
+function skipDeferredTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const plain2 = ctx.trackLines !== true && ctx.captureTrivia !== true;
+  const gap = ctx._gap;
+  if (plain2 && gap !== void 0 && cur === gap.at && input === gap.input && triviaP === gap.of && ctx._rootTriviaCapture === gap.root && ctx.state === gap.state && ctx._rootTriviaKindIndex === gap.rootKinds && ctx._triviaLog === gap.log) return gap.end;
+  const end = clearRunEnd(input, cur, ctx, triviaP, plain2);
+  if (end >= 0) {
+    remember(cur, end, ctx, input, triviaP);
+    return end;
   }
-  return [lo + 1, offset - starts[lo] + 1];
+  const scan = scanTriviaCompact(input, cur, ctx);
+  if (typeof scan !== "number") return commitTriviaScan(scan);
+  if (plain2) remember(cur, scan, ctx, input, triviaP);
+  return scan;
 }
-function spanLines(ctx, start, end) {
-  const s = lineCol(ctx, start), e = lineCol(ctx, end);
-  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+function clearRunEnd(input, cur, ctx, triviaP, plain2) {
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const spec = triviaP?._meta.labeledTriviaSpec;
+  if (!plain2 || triviaP === void 0 || spec == null || rootKinds === void 0 || ctx._triviaLog !== void 0) return -1;
+  if (spec.rootKinds !== rootKinds) prime(spec, triviaP, rootKinds);
+  const fast = spec.rootScan;
+  if (fast === null) return -1;
+  const end = fast(input, cur);
+  return ctx._rootTriviaCapture === false || clearOf(spec.rootLeaders, input, cur, end) ? end : -1;
+}
+function remember(cur, end, ctx, input, triviaP) {
+  const gap = ctx._gap;
+  if (gap === void 0) {
+    ctx._gap = { at: cur, end, input, of: triviaP, root: ctx._rootTriviaCapture, rootKinds: ctx._rootTriviaKindIndex, log: ctx._triviaLog, state: ctx.state };
+    return;
+  }
+  gap.at = cur;
+  gap.end = end;
+  gap.input = input;
+  gap.of = triviaP;
+  gap.root = ctx._rootTriviaCapture;
+  gap.rootKinds = ctx._rootTriviaKindIndex;
+  gap.log = ctx._triviaLog;
+  gap.state = ctx.state;
 }
-function rawEntry(v, input, s, e) {
-  if (typeof v === "object" && v !== null) {
-    const tg = v._tag;
-    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
+function prime(spec, triviaP, rootKinds) {
+  const ranges = [];
+  let bounded = true;
+  for (const arm of spec.arms) {
+    if (rootKinds[arm.label] === void 0) continue;
+    const fs = arm.parser._meta.firstSet;
+    if (fs.kind === "any") bounded = false;
+    else if (fs.kind === "ranges") ranges.push(...fs.ranges);
+  }
+  const classified = triviaP._meta.triviaScanner;
+  spec.rootKinds = rootKinds;
+  spec.rootLeaders = ranges;
+  spec.rootScan = !bounded ? null : classified === void 0 ? fastTriviaScanner(triviaP) : classified;
+}
+function clearOf(ranges, input, from, to) {
+  for (let i = from; i < to; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 55296 && c <= 57343) return false;
+    for (const r of ranges) if (c >= r.lo && c <= r.hi) return false;
   }
-  return {
-    _tag: "leaf",
-    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
-    span: { start: s, end: e }
-  };
+  return true;
 }
-function lead(input, pos) {
-  if (pos >= input.length) return -1;
-  const c = input.charCodeAt(pos);
-  if (c < 55296 || c > 56319) return c;
-  return input.codePointAt(pos) ?? c;
+
+// src/table/fail-clean.ts
+function passChild(code, ip) {
+  switch (code[ip]) {
+    case OP_RULE:
+    case OP_LABEL:
+    case OP_COV:
+    case OP_TOKEN:
+      return code[ip + 1];
+    case OP_GATE:
+    case OP_NODE:
+    case OP_NODE_TRACK:
+    case OP_XFORM:
+    case OP_FIELD:
+    case OP_SCOPE:
+    case OP_SCOPE_CAP:
+    case OP_SCOPE_PLAIN:
+    case OP_WITHCTX:
+    case OP_LEAF:
+    case OP_SOURCE_LEAF:
+      return code[ip + 2];
+    default:
+      return -1;
+  }
+}
+function seqCount(code, ip) {
+  const op = code[ip];
+  return op === OP_SEQ || op === OP_SEQV ? ip + 1 : op === OP_SEQX ? ip + 2 : -1;
+}
+function failCleanAnalysis(code) {
+  const cleanAt = new Uint8Array(code.length);
+  const neverAt = new Uint8Array(code.length);
+  const neverFails = (ip) => {
+    const hit = neverAt[ip];
+    if (hit !== 0) return hit === 1;
+    neverAt[ip] = 3;
+    let out = false;
+    const op = code[ip];
+    if (op === OP_OPT || op === OP_EMPTY || op === OP_EXPECT) out = true;
+    else if (op === OP_REP || op === OP_REPV) out = code[ip + 2] === 0;
+    else {
+      const at = seqCount(code, ip);
+      if (at >= 0) {
+        out = true;
+        for (let i = 1, n = code[at]; out && i <= n; i++) out = neverFails(code[at + i]);
+      } else if (op !== OP_GATE) {
+        const c = passChild(code, ip);
+        out = c >= 0 && neverFails(c);
+      }
+    }
+    neverAt[ip] = out ? 1 : 2;
+    return out;
+  };
+  const clean = (ip) => {
+    const hit = cleanAt[ip];
+    if (hit !== 0) return hit === 1;
+    cleanAt[ip] = 3;
+    let out = false;
+    switch (code[ip]) {
+      // A terminal pushes its leaf only on a match; NOT/PEEK/ATTEMPT restore
+      // their own mark; OPT, EMPTY and EXPECT do not fail uncommitted.
+      case OP_LIT:
+      case OP_RX:
+      case OP_LIT_TRACK:
+      case OP_RX_TRACK:
+      case OP_LIT_CI:
+      case OP_LIT_CI_TRACK:
+      case OP_GUARD:
+      case OP_NOT:
+      case OP_PEEK:
+      case OP_ATTEMPT:
+      case OP_EMPTY:
+      case OP_OPT:
+      case OP_EXPECT:
+        out = true;
+        break;
+      // Min 0 does not fail uncommitted; min 1 fails only with no item kept, and
+      // restores the failed item itself.
+      case OP_REP:
+      case OP_REPV:
+        out = code[ip + 2] <= 1;
+        break;
+      // Only the first term may fail: a later one fails after the terms before it
+      // wrote, and after the trivia scanned in front of it.
+      case OP_SEQ:
+      case OP_SEQV:
+      case OP_SEQX: {
+        const at = seqCount(code, ip);
+        const n = code[at];
+        out = n > 0 && clean(code[at + 1]);
+        for (let i = 2; out && i <= n; i++) out = neverFails(code[at + i]);
+        break;
+      }
+      case OP_CHOICE: {
+        out = true;
+        for (let i = 0, n = code[ip + 2]; out && i < n; i++) out = clean(code[ip + 4 + i]);
+        break;
+      }
+      case OP_ROUTED:
+        out = code[ip + 1] < 0 || clean(code[ip + 1]);
+        break;
+      // An arm's failure and the fallback's are committed; only the selector's is
+      // not, and without a fallback an unknown key fails after the selector wrote.
+      case OP_DISPATCH:
+        out = code[ip + 3] >= 0 && clean(code[ip + 1]);
+        break;
+      default: {
+        const c = passChild(code, ip);
+        out = c >= 0 && clean(c);
+      }
+    }
+    cleanAt[ip] = out ? 1 : 2;
+    return out;
+  };
+  return clean;
 }
 
 // src/grammar-metadata.ts
@@ -11608,12 +12818,6 @@ function hasDirectBuilder(prog) {
   return false;
 }
 
-// src/cst/root-trivia-scope.ts
-var ROOT_TRIVIA_SCOPE_REFUSAL = "parser(): selected root trivia requires classifiedTrivia() for every local trivia scope, or rootCapture: 'opaque'.";
-function refuseUnclassifiedRootScope(strict) {
-  if (strict === true) throw new TypeError(ROOT_TRIVIA_SCOPE_REFUSAL);
-}
-
 // src/table/cell.ts
 var FAIL = /* @__PURE__ */ Symbol("pm.fail");
 var newEndCell = () => ({ e: 0 });
@@ -11664,6 +12868,7 @@ function assemble(t2, prog, cfg) {
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
   const REC = prog.rec === 1 && cfg.tolerant;
+  const PROBE = cfg.probe;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -11678,6 +12883,9 @@ function assemble(t2, prog, cfg) {
   const EC = newEndCell();
   const scalarRecognizers = [];
   const rawScalarSpecs = /* @__PURE__ */ new Set();
+  function lookaheadClass(child) {
+    return code[child] === OP_GATE && !cfg.tolerant && !cfg.probe ? cc[code[child + 1]] : null;
+  }
   function scalarFor(child) {
     const spec = code[child + 1];
     let recognize = scalarRecognizers[spec];
@@ -11687,17 +12895,27 @@ function assemble(t2, prog, cfg) {
     }
     return recognize;
   }
-  const labelExtraIps = [];
-  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) labelExtraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
+  const labelExtraIps = assemblyExtraIps(prog);
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
     hostCst
   );
   let SCAN = null;
+  let HYBRID;
+  function hybridPiece(piece) {
+    const setScan = HYBRID.scan;
+    return (input, pos, ctx) => {
+      const saved = setScan(SCAN);
+      const value = piece(input, pos, ctx);
+      setScan(saved);
+      return value;
+    };
+  }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
+  const NULLABLE = /* @__PURE__ */ new Map();
+  const CLEAN = REC ? () => false : failCleanAnalysis(code);
   function pushLeaf(ctx, value, s, e) {
     const lf = { _tag: "leaf", value, span: { start: s, end: e } };
     pushCstLeaf(ctx, lf);
@@ -11896,6 +13114,22 @@ function assemble(t2, prog, cfg) {
       return node2;
     };
   }
+  function passCollapseNode(child, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const v = child(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
+  function gatedPassCollapseNode(blockers, last, classic, build, readsRaw) {
+    return (input, pos, ctx) => {
+      const c = lead(input, pos);
+      for (let i = 0; i < blockers.length; i++) if (classHas2(blockers[i], c)) return classic(input, pos, ctx);
+      const v = last(input, pos, ctx);
+      if (v !== void 0) return v;
+      return collapseEmpty(ctx, build, input, pos, EC.e, readsRaw);
+    };
+  }
   function plainProjectNode(child, projection, type) {
     return (input, pos, ctx) => {
       const sCh = ctx._cstChildren;
@@ -11987,9 +13221,7 @@ function assemble(t2, prog, cfg) {
       return s(input, cur);
     }
     if (s !== null) return skipTriviaScanned(s, input, cur, ctx);
-    if (needsDeferredTriviaCommit(ctx)) {
-      return commitTriviaScan(scanTriviaCompact(input, cur, ctx));
-    }
+    if (needsDeferredTriviaCommit(ctx)) return skipDeferredTrivia(input, cur, ctx);
     return advanceTrivia(input, cur, ctx);
   }
   let TERMV;
@@ -12159,7 +13391,7 @@ function assemble(t2, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, bits, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -12242,7 +13474,7 @@ function assemble(t2, prog, cfg) {
       if (next !== void 0) {
         return next(input, pos, ctx, c, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot, acc, prev, best);
       }
-      if (best === pos) acc = through(total, prev, acc);
+      if (best === pos && prev !== 0) acc = through(total, prev, acc);
       ctx._fe = pos;
       ctx._fx = acc ?? choiceFx;
       return FAIL;
@@ -12268,21 +13500,27 @@ function assemble(t2, prog, cfg) {
   }
   function dispatchBranch(child, usesRouted) {
     if (!usesRouted) {
-      return (input, _pos, selEnd, key, _selectorMark, ctx) => {
-        const mark = saveTriviaMark(ctx);
+      return (input, _pos, selEnd, key, ctx) => {
+        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;
         const v = child(input, selEnd, ctx);
         if (v === FAIL) {
-          rollbackTrivia(ctx, mark);
+          if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
           ctx._fc = true;
           return FAIL;
         }
         return [key, v];
       };
     }
-    return (input, pos, selEnd, key, selectorMark, ctx) => {
+    return (input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot) => {
       const savedRouted = ctx._routed;
-      rollbackTrivia(ctx, selectorMark);
-      const mark = saveTriviaMark(ctx);
+      if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
       ctx._routed = { value: key, span: { start: pos, end: selEnd } };
       let v;
       try {
@@ -12291,7 +13529,7 @@ function assemble(t2, prog, cfg) {
         ctx._routed = savedRouted;
       }
       if (v === FAIL) {
-        rollbackTrivia(ctx, mark);
+        if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
         ctx._fc = true;
         return FAIL;
       }
@@ -12299,12 +13537,12 @@ function assemble(t2, prog, cfg) {
     };
   }
   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);
+    return (arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot) => {
+      if (arm === start) return a0(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 1) return a1(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 2) return a2(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      if (arm === start + 3) return a3(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+      return next === void 0 ? FAIL : next(arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
     };
   }
   function trackLinesInto(ctx, input, end) {
@@ -12321,20 +13559,68 @@ function assemble(t2, prog, cfg) {
     if (done !== void 0) return done;
     const flight = inFlight.get(ip);
     if (flight !== void 0) return flight.fwd;
+    const selected = HYBRID?.byIp[ip];
+    if (selected !== void 0) {
+      const piece2 = scanHandoffNeeded(code, ip, closureLabels) ? hybridPiece(selected) : selected;
+      memo.set(ip, piece2);
+      reached.add(ip);
+      return piece2;
+    }
     let target;
     const fwd = (input, pos, ctx) => target(input, pos, ctx);
     const holder = { fwd, set: (p) => {
       target = p;
     } };
     inFlight.set(ip, holder);
-    const op = code[ip];
-    const piece = (op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && closureLabels.at(ip).tri === code[ip + 1] ? link(code[ip + 2]) : lower(ip);
+    const piece = scopeIsIdentity(code, ip, closureLabels.at(ip)) ? link(code[ip + 2]) : countedPiece(lookaheadLedNode(ip) ?? lower(ip), ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
     reached.add(ip);
     return piece;
   }
+  let FIRST_DECIDED;
+  let NODE_BODY;
+  const DECIDED = (_input, pos) => {
+    EC.e = pos;
+    return null;
+  };
+  function lookaheadLedNode(ip) {
+    const op = code[ip];
+    if (op !== OP_NODE && op !== OP_NODE_TRACK || hostCst || REC || cfg.probe || cfg.coverage || cfg.trackLines) return void 0;
+    if (passCollapse(code, ip, hostCst) || gatedPassCollapse(code, ip, hostCst) !== void 0) return void 0;
+    const body = code[ip + 2];
+    const bop = code[body];
+    if (bop !== OP_SEQ && bop !== OP_SEQV && bop !== OP_SEQX) return void 0;
+    const base = bop === OP_SEQX ? body + 3 : body + 2;
+    if (code[bop === OP_SEQX ? body + 2 : body + 1] < 2) return void 0;
+    const first = code[base];
+    const negative = code[first] === OP_NOT;
+    const terminal = negative ? scalarTerminalNotChild(code, first) : code[first] === OP_PEEK ? scalarTerminalPeekChild(code, first) : -1;
+    if (terminal < 0) return void 0;
+    const recognize = scalarFor(terminal);
+    const xf = fx[code[first + 2]];
+    FIRST_DECIDED = DECIDED;
+    NODE_BODY = lower(body);
+    const node2 = lower(ip);
+    NODE_BODY = void 0;
+    return negative ? (input, pos, ctx) => {
+      if (recognize(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        EC.e = pos;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    } : (input, pos, ctx) => {
+      if (recognize(input, pos) < 0) {
+        ctx._fe = pos;
+        ctx._fx = xf;
+        return FAIL;
+      }
+      return node2(input, pos, ctx);
+    };
+  }
   function lower(ip) {
     const op = code[ip];
     switch (op) {
@@ -12865,7 +14151,12 @@ function assemble(t2, prog, cfg) {
         }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -12874,8 +14165,10 @@ 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;
+          const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             EC.e = pos;
             return null;
@@ -12886,9 +14179,29 @@ function assemble(t2, prog, cfg) {
         };
       }
       case OP_PEEK: {
+        const scalarChild = scalarTerminalPeekChild(code, ip);
+        if (scalarChild >= 0) {
+          const recognize = scalarFor(scalarChild);
+          const xf2 = fx[code[ip + 2]];
+          return (input, pos, ctx) => {
+            if (recognize(input, pos) < 0) {
+              ctx._fe = pos;
+              ctx._fx = xf2;
+              return FAIL;
+            }
+            EC.e = pos;
+            return null;
+          };
+        }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            ctx._fe = pos;
+            ctx._fx = xf;
+            return FAIL;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -12897,8 +14210,10 @@ 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;
+          const probeBest = PROBE ? ctx._probe?.best : void 0;
           const v = child(input, pos, ctx);
           if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+          if (PROBE && ctx._probe !== void 0) ctx._probe.best = probeBest ?? null;
           if (v === FAIL) {
             ctx._fe = pos;
             ctx._fx = xf;
@@ -12910,8 +14225,14 @@ function assemble(t2, prog, cfg) {
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const gate = lookaheadClass(code[ip + 1]);
+        const childClean = CLEAN(code[ip + 1]);
         return (input, pos, ctx) => {
-          const need = markCst(ctx);
+          if (gate !== null && !classHas2(gate, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
+          const need = !childClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -13109,6 +14430,9 @@ function assemble(t2, prog, cfg) {
         const projection = reducer < 0 ? ~reducer : -1;
         const fn = fused && projection < 0 ? fns[reducer] : void 0;
         const step = closureLabels.at(ip).buf ? nextTermBuffered : nextTerm;
+        const decided = FIRST_DECIDED;
+        FIRST_DECIDED = void 0;
+        const linkFirst = () => decided ?? link(code[base]);
         const runnerBlock = (count, r0, r1, r2, r3, next) => {
           if (count === 1) return (input, cur, ctx, values, inherited) => {
             cur = r0(input, cur, ctx, inherited);
@@ -13154,7 +14478,7 @@ function assemble(t2, prog, cfg) {
           };
         };
         if (REC) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
             const sync = sentinelFor(code[base + n + i]);
@@ -13190,13 +14514,13 @@ function assemble(t2, prog, cfg) {
           const bindRunners = (start) => {
             const count = Math.min(4, n - start);
             const at = (offset) => runnerAt(start + offset);
-            const never = () => -1;
+            const never2 = () => -1;
             return runnerBlock(
               count,
               at(0),
-              count > 1 ? at(1) : never,
-              count > 2 ? at(2) : never,
-              count > 3 ? at(3) : never,
+              count > 1 ? at(1) : never2,
+              count > 2 ? at(2) : never2,
+              count > 3 ? at(3) : never2,
               start + count < n ? bindRunners(start + count) : void 0
             );
           };
@@ -13246,15 +14570,31 @@ function assemble(t2, prog, cfg) {
         let hasAdj = false;
         for (let i = 1; i < n; i++) {
           const kidIp = code[base + i];
-          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp)) {
+          if (code[kidIp] === OP_ADJ || leadingTriviaFieldAt(code, k, kidIp) || holdsGap(code, k, base, n, i, NULLABLE)) {
             hasAdj = true;
             break;
           }
         }
         if (hasAdj) {
-          const first2 = link(code[base]);
+          const first2 = linkFirst();
           const runnerAt = (i) => {
             const kidIp = code[base + i];
+            if (holdsGap(code, k, base, n, i, NULLABLE)) {
+              const kid = link(kidIp);
+              return (input, cur, ctx) => {
+                if (ctx.trivia === void 0) {
+                  const v2 = kid(input, cur, ctx);
+                  if (v2 === FAIL) return -1;
+                  TERMV = v2;
+                  return EC.e;
+                }
+                const scanEnd = skipTrivia(input, cur, ctx);
+                const v = kid(input, scanEnd, ctx);
+                if (v === FAIL) return -1;
+                TERMV = v;
+                return scanEnd;
+              };
+            }
             if (code[kidIp] !== OP_ADJ) {
               const kid = link(kidIp);
               if (leadingTriviaFieldAt(code, k, kidIp)) {
@@ -13279,13 +14619,13 @@ function assemble(t2, prog, cfg) {
           const bindRunners = (start) => {
             const count = Math.min(4, n - start);
             const at = (offset) => runnerAt(start + offset);
-            const never = () => -1;
+            const never2 = () => -1;
             return runnerBlock(
               count,
               at(0),
-              count > 1 ? at(1) : never,
-              count > 2 ? at(2) : never,
-              count > 3 ? at(3) : never,
+              count > 1 ? at(1) : never2,
+              count > 2 ? at(2) : never2,
+              count > 3 ? at(3) : never2,
               start + count < n ? bindRunners(start + count) : void 0
             );
           };
@@ -13322,7 +14662,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 1) {
-          const k0 = link(code[base]);
+          const k0 = linkFirst();
           if (fused) {
             return (input, pos, ctx) => {
               const v = k0(input, pos, ctx);
@@ -13344,7 +14684,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 2) {
-          const k0 = link(code[base]), k1 = link(code[base + 1]);
+          const k0 = linkFirst(), k1 = link(code[base + 1]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -13375,7 +14715,7 @@ function assemble(t2, prog, cfg) {
           };
         }
         if (n === 3) {
-          const k0 = link(code[base]), k1 = link(code[base + 1]), k2 = link(code[base + 2]);
+          const k0 = linkFirst(), k1 = link(code[base + 1]), k2 = link(code[base + 2]);
           if (fused) {
             return (input, pos, ctx) => {
               const v0 = k0(input, pos, ctx);
@@ -13469,7 +14809,7 @@ function assemble(t2, prog, cfg) {
             start + count < n ? bind(start + count) : void 0
           );
         };
-        const first = link(code[base]);
+        const first = linkFirst();
         const tail = bind(1);
         const runDirectTerms = (input, pos, ctx, values) => {
           const v0 = first(input, pos, ctx);
@@ -13508,6 +14848,8 @@ function assemble(t2, prog, cfg) {
         const n = code[ip + 2];
         const choiceFx = fx[code[ip + 3]];
         const base = ip + 4;
+        for (let i = 0; i < n; i++) link(code[base + i]);
+        const armsClean = CLEAN(ip);
         if (table.exclusive) {
           const ascii = table.ascii;
           const hi = table.hi;
@@ -13647,7 +14989,7 @@ function assemble(t2, prog, cfg) {
           if (n === 3) addGate(g2, 4);
           return (input, pos, ctx) => {
             const c = lead(input, pos);
-            const need = markCst(ctx);
+            const need = !armsClean && markCst(ctx);
             const mRaw = MRAW;
             const mTl = MTL;
             const mLv = MLV;
@@ -13717,6 +15059,11 @@ function assemble(t2, prog, cfg) {
                 }
                 if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               }
+              if (prev === 0) {
+                ctx._fe = pos;
+                ctx._fx = choiceFx;
+                return FAIL;
+              }
               if (best === pos && prev < 1) acc = accSet(e0, acc);
               if (best === pos && prev < 2) acc = accSet(e1, acc);
               if (best === pos && n === 3 && prev < 3) acc = accSet(e2, acc);
@@ -13859,7 +15206,7 @@ function assemble(t2, prog, cfg) {
           if (pn !== 0) {
             return (input, pos, ctx) => {
               const c = lead(input, pos);
-              const need = markCst(ctx);
+              const need = !armsClean && markCst(ctx);
               const mRaw = MRAW;
               const mTl = MTL;
               const mLv = MLV;
@@ -13916,7 +15263,7 @@ function assemble(t2, prog, cfg) {
           }
           return (input, pos, ctx) => {
             const c = lead(input, pos);
-            const need = markCst(ctx);
+            const need = !armsClean && markCst(ctx);
             const mRaw = MRAW;
             const mTl = MTL;
             const mLv = MLV;
@@ -13964,7 +15311,7 @@ function assemble(t2, prog, cfg) {
         }
         return (input, pos, ctx) => {
           const c = lead(input, pos);
-          const need = markCst(ctx);
+          const need = !armsClean && markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
           const mLv = MLV;
@@ -14018,6 +15365,21 @@ function assemble(t2, prog, cfg) {
           return lit(input, pos, ctx);
         };
       }
+      case OP_RGATE: {
+        const cls = cc[code[ip + 1]];
+        const xf = fx[code[ip + 3]];
+        const child = link(code[ip + 2]);
+        if (cfg.tolerant || cfg.probe) return child;
+        return (input, pos, ctx) => {
+          const item = ctx._routed;
+          if (item !== void 0 && item.span.start === pos && !classHas2(cls, lead(input, item.span.end))) {
+            ctx._fe = item.span.end;
+            ctx._fx = xf;
+            return FAIL;
+          }
+          return child(input, pos, ctx);
+        };
+      }
       case OP_ARMGATE: {
         const pred = fns[code[ip + 1]];
         const child = link(code[ip + 2]);
@@ -14025,7 +15387,7 @@ function assemble(t2, prog, cfg) {
         return (input, pos, ctx) => {
           if (!pred(ctx.state)) {
             ctx._fc = false;
-            ctx._fe = pos;
+            ctx._fe = -1;
             ctx._fx = xf;
             return FAIL;
           }
@@ -14086,6 +15448,7 @@ function assemble(t2, prog, cfg) {
         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;
+        const itemClean = sepIp < 0 && CLEAN(code[ip + 1]) && !rowNullable(code, k, code[ip + 1], NULLABLE);
         if (REC) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
@@ -14182,6 +15545,8 @@ function assemble(t2, prog, cfg) {
           const out = collect ? [] : void 0;
           const hasTrivia = ctx.trivia !== void 0;
           const needMark = rollbackNeeded(ctx);
+          const markLater = needMark && (!itemClean || hasTrivia);
+          const markFirst = needMark && (!itemClean || hasTrivia && skipBeforeFirst);
           const gateItems = itemMayStart !== void 0 && ctx._probe === void 0;
           let cur = pos;
           let count = 0;
@@ -14189,14 +15554,15 @@ function assemble(t2, prog, cfg) {
             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;
-            const mLv = needMark ? MLV : 0;
-            const mFl = needMark ? ctx._fields?.length ?? 0 : 0;
-            const mEr = needMark ? ctx._errors?.length ?? 0 : 0;
-            const mLog = needMark ? ctx._triviaLog?.length ?? 0 : 0;
-            const mRoot = needMark ? ctx._rootTriviaLog?.length ?? 0 : 0;
+            const markIt = count > 0 ? markLater : markFirst;
+            if (markIt) markCst(ctx);
+            const mRaw = markIt ? MRAW : 0;
+            const mTl = markIt ? MTL : 0;
+            const mLv = markIt ? MLV : 0;
+            const mFl = markIt ? ctx._fields?.length ?? 0 : 0;
+            const mEr = markIt ? ctx._errors?.length ?? 0 : 0;
+            const mLog = markIt ? ctx._triviaLog?.length ?? 0 : 0;
+            const mRoot = markIt ? ctx._rootTriviaLog?.length ?? 0 : 0;
             let itemStart = cur;
             let sepEnd = -1;
             const viaRepItem = sep === void 0 && count >= min && (count > 0 || skipBeforeFirst);
@@ -14208,7 +15574,7 @@ function assemble(t2, prog, cfg) {
               if (sepLeads) LEAD.at = cur;
               const sv = sep(input, sp, ctx);
               if (sv === FAIL) {
-                if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+                if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
                 if (committed3(ctx)) return FAIL;
                 break;
               }
@@ -14219,25 +15585,25 @@ function assemble(t2, prog, cfg) {
               itemStart = skipTrivia(input, itemStart, ctx);
             }
             if (itemStart >= input.length && viaRepItem) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               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 (markIt) 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 (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               if (committed3(ctx)) return FAIL;
               if (trailingAllowed && sepEnd >= 0) cur = sepEnd;
               break;
             }
             if (EC.e === itemStart && viaRepItem) {
-              if (needMark) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+              if (markIt) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
               break;
             }
             if (out !== void 0) out.push(v);
@@ -14311,7 +15677,14 @@ function assemble(t2, prog, cfg) {
         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 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;
           const selVal = selector(input, pos, ctx);
           if (selVal === FAIL) return FAIL;
           const selEnd = EC.e;
@@ -14323,9 +15696,9 @@ function assemble(t2, prog, cfg) {
               ctx._fx = expected;
               return FAIL;
             }
-            return runOther(input, pos, selEnd, key, selectorMark, ctx);
+            return runOther(input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
           }
-          return runArm(arm, input, pos, selEnd, key, selectorMark, ctx);
+          return runArm(arm, input, pos, selEnd, key, ctx, need, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
         };
       }
       /* ── node ────────────────────────────────────────────────────────────── */
@@ -14361,7 +15734,8 @@ function assemble(t2, prog, cfg) {
             return nd;
           };
         }
-        const child = link(code[ip + 2]);
+        const child = NODE_BODY ?? link(code[ip + 2]);
+        NODE_BODY = void 0;
         const proj = code[ip + 4];
         const buildIdx = code[ip + 1];
         const type = k[code[ip + 5]];
@@ -14385,6 +15759,30 @@ function assemble(t2, prog, cfg) {
           if (build !== void 0 && proj < 0 && flags === 18) {
             return childrenOnlyFieldsBuildNode(child, build);
           }
+          if (build !== void 0 && passCollapse(code, ip, hostCst)) {
+            return passCollapseNode(child, build, flags === 32);
+          }
+          const gated = build !== void 0 && !cfg.tolerant && !cfg.probe ? gatedPassCollapse(code, ip, hostCst) : void 0;
+          const triviaLead = gated === void 0 ? void 0 : triviaLeadRanges(closureLabels.at(code[ip + 2]).tri, trivia2);
+          if (build !== void 0 && gated !== void 0 && triviaLead !== void 0) {
+            const classic = flags === 32 ? collapseBuildNode(child, build) : childrenOnlyCollapseBuildNode(child, build);
+            return gatedPassCollapseNode(
+              [
+                ...gated.leads.map((g) => cc[code[g + 1]]),
+                resolveClass(encodeClassSpec([
+                  ...triviaLead,
+                  ...gated.lits.map((i) => {
+                    const c = k[i].codePointAt(0);
+                    return { lo: c, hi: c };
+                  })
+                ]))
+              ],
+              link(gated.last),
+              classic,
+              build,
+              flags === 32
+            );
+          }
           if (build !== void 0 && proj < 0 && flags === 32) {
             return collapseBuildNode(child, build);
           }
@@ -14431,7 +15829,7 @@ function assemble(t2, prog, cfg) {
           if (v === FAIL) return FAIL;
           const end = EC.e;
           const span = tracked ? spanLines(ctx, pos, end) : { start: pos, end };
-          const st = readsState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+          const st = readsState ? ctx.state : void 0;
           let nd;
           if (unwrap && kids.length === 1) {
             nd = unwrapChild(kids[0]);
@@ -14444,10 +15842,10 @@ function assemble(t2, prog, cfg) {
           ) {
             nd = kids[0];
           } else if (proj >= 0) {
-            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags) : projectChild(kids, proj, type);
+            nd = hostCst && host !== void 0 ? host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags) : projectChild(kids, proj, type);
           } else if (build !== void 0) {
             if (hostCst && host !== void 0) {
-              nd = host(type, kids, fieldMap, span, rawKids, tlog, readsState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0, tags);
+              nd = host(type, kids, fieldMap, span, rawKids, tlog, ctx.state, tags);
             } else {
               nd = build(kids, fieldMap, span, rawKids, captureWide ? tlog : EMPTY_TL2, st);
             }
@@ -14498,9 +15896,7 @@ function assemble(t2, prog, cfg) {
   let emitRefusal;
   let emitReached;
   {
-    const extraIps = [];
-    for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
-    for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+    const extraIps = assemblyExtraIps(prog);
     const roots = [...Object.values(prog.rules), ...extraIps];
     for (const ip of reachableSites(code, roots)) {
       if (code[ip] === OP_DISPATCH) {
@@ -14535,6 +15931,8 @@ function assemble(t2, prog, cfg) {
       }
       const notChild = scalarTerminalNotChild(code, ip);
       if (notChild >= 0) scalarFor(notChild);
+      const peekChild = scalarTerminalPeekChild(code, ip);
+      if (peekChild >= 0) scalarFor(peekChild);
     }
     const pre = cfg.hostCaptureTrivia === void 0 ? prog.asm?.find((a) => a.key === cfgKey(cfg)) : void 0;
     if (pre !== void 0) {
@@ -14593,9 +15991,12 @@ function assemble(t2, prog, cfg) {
         adjacencyHolds,
         t2.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = new Set(pre.reached);
+      if (emitted.ext !== void 0) HYBRID = emitted;
     }
     try {
       if (emitted !== void 0) throw new ServedByBuild();
@@ -14677,7 +16078,9 @@ function assemble(t2, prog, cfg) {
         adjacencyHolds,
         t2.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia,
+        collapseEmpty
       );
       emitReached = em.reached;
     } catch (e) {
@@ -14688,7 +16091,7 @@ function assemble(t2, prog, cfg) {
   }
   function pieceAt(ip) {
     const em = emitted;
-    if (em !== void 0) {
+    if (em !== void 0 && HYBRID === void 0) {
       const p = em.byIp[ip];
       if (p === void 0) throw new Error(`table emitter: no emitted body for site ${ip}`);
       return p;
@@ -14718,6 +16121,37 @@ function assemble(t2, prog, cfg) {
   }
   const scans = scansArr;
   const scanSkip = (prog.scanSkip ?? []).map((set) => set.map((r) => subtreeComb(r)));
+  if (HYBRID !== void 0) {
+    const em = HYBRID;
+    em.bind(
+      (s) => {
+        const saved = SCAN;
+        SCAN = s;
+        return saved;
+      },
+      em.ext.map((ip) => link(ip))
+    );
+    const pieces2 = {};
+    for (const [name, entryIp] of Object.entries(prog.rules)) {
+      pieces2[name] = em.pieces[name] ?? link(entryIp);
+    }
+    for (const ip of emitReached) reached.add(ip);
+    return {
+      pieces: pieces2,
+      end: () => EC.e,
+      begin: (ctx) => {
+        begin(ctx);
+        em.begin(ctx);
+      },
+      finish: () => {
+        em.finish();
+        finish();
+      },
+      scanSkip,
+      reached,
+      emitRefusal: void 0
+    };
+  }
   if (emitted !== void 0) {
     const em = emitted;
     return {
@@ -14753,6 +16187,15 @@ function assemble(t2, prog, cfg) {
   }
   return { pieces, end: () => EC.e, begin, finish, scanSkip, reached, emitRefusal };
 }
+var SITE_COUNTS;
+function countedPiece(piece, ip) {
+  const counts = SITE_COUNTS;
+  if (counts === void 0) return piece;
+  return (input, pos, ctx) => {
+    counts[ip]++;
+    return piece(input, pos, ctx);
+  };
+}
 var AssemblyCache = class {
   t;
   prog;
@@ -14904,7 +16347,7 @@ function emitClassPool(classes) {
   if (classes.length < 2) return array;
   const delimiter = "|/~?^`".split("").find((ch2) => classes.every((spec) => !spec.includes(ch2)));
   if (delimiter === void 0) return array;
-  const split = `${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`;
+  const split = `/* @__PURE__ */ ${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`;
   return split.length < array.length ? split : array;
 }
 function emitConst(v) {
@@ -14955,9 +16398,7 @@ function emitDispatchSpec(d) {
 function emitAssemblies(prog, cfgs) {
   if (cfgs.length === 0) return ["a:[],"];
   const t2 = resolveTable(prog);
-  const extraIps = [];
-  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+  const extraIps = assemblyExtraIps(prog);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const cfg of cfgs) {
@@ -14966,7 +16407,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t2, prog, cfg, extraIps, true);
+      em = emitAssemblySource(t2, prog, cfg, extraIps, true, cfg.select);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -16513,339 +17954,85 @@ function reportDuplication(opt, analyze) {
     if (level === "error") throw new Error(`parseman: ${duplicationFindingCount(report)} duplication/overlap finding(s)
 ${lines2.join("\n")}`);
     for (const l of lines2) console.warn(l);
-  }
-  return report;
-}
-function runDuplicationDiagnostic(combinator, opt) {
-  return reportDuplication(opt, (o) => analyzeDuplication(combinator, o));
-}
-function runDuplicationDiagnosticRules(ruleMap, opt) {
-  return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
-}
-
-// src/table/compile-rule-map.ts
-function resolveHostMode(ruleMap, explicit) {
-  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
-}
-function resolveTrackLines(ruleMap, explicit) {
-  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
-}
-function withAmbient(ruleMap, opts) {
-  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
-  const wrappers = /* @__PURE__ */ new Map();
-  return ruleMap.map(([name, rule2]) => {
-    if (rule2._meta.isTrivia) return [name, rule2];
-    const addTrivia = opts.trivia !== void 0 && rule2._meta.grammarTrivia === void 0;
-    const addScanSkip = opts.scanSkip !== void 0 && rule2._meta.grammarScanSkip === void 0;
-    if (!addTrivia && !addScanSkip) return [name, rule2];
-    let wrapped = wrappers.get(rule2);
-    if (wrapped === void 0) {
-      wrapped = {
-        ...rule2,
-        _meta: {
-          ...rule2._meta,
-          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
-          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
-        }
-      };
-      wrappers.set(rule2, wrapped);
-    }
-    return [name, wrapped];
-  });
-}
-function compileRuleMapRunnable(ruleMap, opts = {}) {
-  const encoded = encodeForRun(ruleMap, opts);
-  if (encoded === null) return null;
-  const { prog, hostMode, plan } = encoded;
-  const artifact = closureArtifact(prog);
-  const reflection = collectGrammarReflection(ruleMap);
-  return {
-    keys: ruleMap.map(([key]) => key),
-    hostMode,
-    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule2]) => hasDirectBuildDef(rule2)),
-    reflection,
-    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
-    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
-    // asks to specialise; every other caller runs the closure artifact.
-    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
-    prog: artifact
-  };
-}
-function encodeForRun(ruleMap, opts) {
-  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
-  const encodeMap = withAmbient(ruleMap, opts);
-  const plan = opts.coverage === true ? buildGrammarPlan(
-    encodeMap.map(([, rule2]) => rule2),
-    Object.fromEntries(encodeMap.filter(([, rule2]) => rule2._def.tag !== "lazy"))
-  ) : void 0;
-  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
-  const settings = {
-    hostMode,
-    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
-    ...opts.recovery === true ? { recovery: true } : {},
-    ...plan === void 0 ? {} : { coverage: plan }
-  };
-  try {
-    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
-    return { prog, fnSrcs, hostMode, plan };
-  } catch (e) {
-    opts.refusals?.push(e instanceof Error ? e.message : String(e));
-    return null;
-  }
-}
-
-// src/compiler/value-usage.ts
-function markUnusedValues(root) {
-  const seenConsumed = /* @__PURE__ */ new WeakSet();
-  const seenUnconsumed = /* @__PURE__ */ new WeakSet();
-  const mark = (def, consumed) => {
-    if (consumed) def.valueUnused = false;
-    else if (def.valueUnused !== false) def.valueUnused = true;
-  };
-  const visit = (c, consumed) => {
-    const seen = consumed ? seenConsumed : seenUnconsumed;
-    if (seen.has(c)) return;
-    seen.add(c);
-    const def = c._def;
-    switch (def.tag) {
-      case "many":
-      case "oneOrMore":
-        mark(def, consumed);
-        visit(def.parser, consumed);
-        return;
-      case "optional":
-        visit(def.parser, consumed);
-        return;
-      case "sequence":
-        mark(def, consumed);
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "choice":
-        for (const p of def.parsers) visit(p, consumed);
-        return;
-      case "dispatch":
-        visit(def.selector, consumed);
-        for (const entry of def.cases) visit(entry.parser, consumed);
-        if (def.matchers) for (const entry of def.matchers) visit(entry.parser, consumed);
-        if (def.otherwise) visit(def.otherwise, consumed);
-        return;
-      case "node":
-        visit(def.parser, false);
-        return;
-      case "transform":
-        visit(def.parser, true);
-        return;
-      case "field":
-        visit(def.parser, true);
-        return;
-      case "sepBy":
-        visit(def.parser, true);
-        visit(def.separator, false);
-        return;
-      case "not":
-      case "peek":
-        visit(def.parser, false);
-        return;
-      case "grammar":
-        visit(def.parser, consumed);
-        if (def.triviaParser) visit(def.triviaParser, false);
-        return;
-      case "recover":
-        visit(def.parser, consumed);
-        visit(def.sentinel, false);
-        return;
-      case "token":
-        visit(def.parser, false);
-        return;
-      case "label":
-      case "trivia":
-      case "attempt":
-      case "withCtx":
-      case "expect":
-        visit(def.parser, consumed);
-        return;
-      case "leaf":
-        visit(def.parser, true);
-        return;
-      case "lazy":
-        return;
-      default:
-        return;
-    }
-  };
-  const resolveRoot = (c) => {
-    const guard = /* @__PURE__ */ new Set();
-    let cur = c;
-    while (!guard.has(cur)) {
-      const d = cur._def;
-      if (d.tag === "grammar") {
-        guard.add(cur);
-        cur = d.parser;
-        continue;
-      }
-      if (d.tag !== "lazy") return cur;
-      guard.add(cur);
-      try {
-        cur = d.thunk();
-      } catch {
-        return c;
-      }
-    }
-    return cur;
-  };
-  visit(resolveRoot(root), true);
+  }
+  return report;
+}
+function runDuplicationDiagnostic(combinator, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplication(combinator, o));
+}
+function runDuplicationDiagnosticRules(ruleMap, opt) {
+  return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
-// src/combinators/grammar.ts
-function annotateResultLines(result, index) {
-  const annotated = { ...result, span: annotateSpan(result.span, index) };
-  const errors = annotated.errors;
-  if (errors) {
-    ;
-    annotated.errors = errors.map((error) => ({
-      ...error,
-      span: annotateSpan(error.span, index)
-    }));
-  }
-  return annotated;
+// src/table/compile-rule-map.ts
+function resolveHostMode(ruleMap, explicit) {
+  return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
 }
-function createParseLineContext(input, pos) {
-  const lineIndex = createLineIndex();
-  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
-  return { lineIndex, lineScannedTo: pos };
+function resolveTrackLines(ruleMap, explicit) {
+  return explicit === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
 }
-var TRACK_LINES_ON = () => true;
-var TRACK_LINES_OFF = () => false;
-var TRACK_LINES_INHERIT = (ctx) => ctx?.trackLines === true;
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  const opaqueRootCapture = opts.rootCapture === "opaque";
-  if (opaqueRootCapture && opts.trivia === void 0) {
-    throw new TypeError("parser({ rootCapture: 'opaque' }) requires an explicit trivia scope.");
-  }
-  const scopeTrivia = clearTrivia ? void 0 : opts.trivia ?? void 0;
-  const scopeLabels = scopeTrivia?._meta?.triviaKindLabels;
-  const refuseUnclassified = scopeTrivia !== void 0 && !scopeTrivia._meta?.rootTriviaClassified && !opaqueRootCapture;
-  const forceCaptureTrivia = opts.captureTrivia === true;
-  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;
-  const rootScalar = scalarOf(root);
-  const scalarEligible = opts.trackLines !== true && opts.recover !== true && !opaqueRootCapture && !forceCaptureTrivia && captureKinds === void 0;
-  const parseScalar = scalarEligible ? (input, pos, ctx) => {
-    const savedTrivia = ctx.trivia;
-    const savedLabels = ctx.triviaKindLabels;
-    if (clearTrivia) {
-      ctx.trivia = void 0;
-      ctx.triviaKindLabels = void 0;
-    } else if (scopeTrivia !== void 0) {
-      ctx.trivia = scopeTrivia;
-      ctx.triviaKindLabels = scopeLabels;
-    }
-    const end = rootScalar(input, pos, ctx);
-    ctx.trivia = savedTrivia;
-    ctx.triviaKindLabels = savedLabels;
-    return end;
-  } : void 0;
-  let publicScalar;
-  const grammar = {
-    _tag: "grammar",
-    _meta: {
-      ...root._meta,
-      // Trivia classification describes this grammar's own active trivia
-      // scope. A directly nested grammar may have classified trivia of its
-      // own, but that must not advertise classification for this wrapper.
-      triviaKindLabels: void 0,
-      rootTriviaClassified: void 0,
-      ...opts.trivia?._meta?.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {},
-      ...opts.trivia?._meta?.rootTriviaClassified ? { rootTriviaClassified: true } : {}
-    },
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: scopeTrivia,
-      clearTrivia,
-      ...opaqueRootCapture ? { rootCapture: "opaque" } : {},
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false,
-      constructionTrackLines: trackLinesPolicy,
-      ...captureKinds === void 0 ? {} : { constructionCaptureTriviaKinds: captureKinds }
-    },
-    _parseScalar: parseScalar,
-    parse(input, pos, _ctx) {
-      if (pos === void 0 && _ctx === void 0) {
-        publicScalar ??= scalarRootOf(grammar) ?? null;
-        if (publicScalar) {
-          const ctx2 = createParseContext();
-          const end = publicScalar(input, 0, ctx2);
-          if (end < 0) {
-            const at = ~end;
-            return { ok: false, expected: ctx2._fx ?? [], span: { start: at, end: at } };
-          }
-          return { ok: true, value: ctx2._sv, span: { start: 0, end } };
+function withAmbient(ruleMap, opts) {
+  if (opts.trivia === void 0 && opts.scanSkip === void 0) return ruleMap;
+  const wrappers = /* @__PURE__ */ new Map();
+  return ruleMap.map(([name, rule2]) => {
+    if (rule2._meta.isTrivia) return [name, rule2];
+    const addTrivia = opts.trivia !== void 0 && rule2._meta.grammarTrivia === void 0;
+    const addScanSkip = opts.scanSkip !== void 0 && rule2._meta.grammarScanSkip === void 0;
+    if (!addTrivia && !addScanSkip) return [name, rule2];
+    let wrapped = wrappers.get(rule2);
+    if (wrapped === void 0) {
+      wrapped = {
+        ...rule2,
+        _meta: {
+          ...rule2._meta,
+          ...addTrivia ? { grammarTrivia: opts.trivia } : {},
+          ...addScanSkip ? { grammarScanSkip: opts.scanSkip } : {}
         }
-      }
-      if (refuseUnclassified) refuseUnclassifiedRootScope(_ctx?._rootTriviaStrictScopes);
-      const trackLines = trackLinesOf(_ctx);
-      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
-      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
-      const ctx = _ctx === void 0 ? createParseContext() : { ..._ctx };
-      ctx.trackLines = trackLines;
-      if (lineIndex) ctx._lineIndex = lineIndex;
-      if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-      if (clearTrivia) {
-        ctx.trivia = void 0;
-        ctx.triviaKindLabels = void 0;
-      } else if (scopeTrivia !== void 0) {
-        ctx.trivia = scopeTrivia;
-        if (scopeLabels) ctx.triviaKindLabels = scopeLabels;
-      }
-      if (forceCaptureTrivia || _ctx?.captureTrivia) ctx.captureTrivia = true;
-      if (ownCaptureMask !== void 0) ctx._triviaCaptureMask = ownCaptureMask;
-      else if (inheritCaptureMask) ctx._triviaCaptureMask = triviaKindMask(_ctx?.triviaKindLabels, captureKinds);
-      if (opaqueRootCapture) ctx._rootTriviaCapture = false;
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
-      }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+      };
+      wrappers.set(rule2, wrapped);
     }
+    return [name, wrapped];
+  });
+}
+function compileRuleMapRunnable(ruleMap, opts = {}) {
+  const encoded = encodeForRun(ruleMap, opts);
+  if (encoded === null) return null;
+  const { prog, hostMode, plan } = encoded;
+  const artifact = closureArtifact(prog);
+  const reflection = collectGrammarReflection(ruleMap);
+  return {
+    keys: ruleMap.map(([key]) => key),
+    hostMode,
+    hostBranchElided: hostMode === "ast" && ruleMap.some(([, rule2]) => hasDirectBuildDef(rule2)),
+    reflection,
+    ...plan === void 0 ? {} : { coverageDefinitions: plan.definitions },
+    // Reflection rides on the map's metadata prototype from birth. Only `compile()`
+    // asks to specialise; every other caller runs the closure artifact.
+    rules: tableRules(opts.specialise === true ? prog : artifact, { [GRAMMAR_REFLECTION]: reflection }),
+    prog: artifact
   };
-  return grammar;
 }
-var _analyzed = /* @__PURE__ */ new WeakSet();
-function parse(combinator, input, opts = {}) {
-  if (!_analyzed.has(combinator)) {
-    _analyzed.add(combinator);
-    markUnusedValues(combinator);
-  }
-  if (!opts.trackLines && !opts.recover && combinator._def.tag === "grammar" && combinator._meta.grammarScanSkip === void 0) {
-    return combinator.parse(input);
-  }
-  const trackLines = opts.trackLines ?? combinator._meta.grammarTrackLines ?? false;
-  const lineContext = trackLines ? createParseLineContext(input, 0) : void 0;
-  const lineIndex = lineContext?.lineIndex;
-  const _errors = opts.recover ? [] : void 0;
-  const _probe = opts.recover ? { offset: input.length, best: null } : void 0;
-  const grammarTrivia = combinator._meta.grammarTrivia;
-  const grammarScanSkip = combinator._meta.grammarScanSkip;
-  const ctx = createParseContext();
-  ctx.trackLines = trackLines;
-  if (lineIndex) ctx._lineIndex = lineIndex;
-  if (lineContext) ctx._lineScannedTo = lineContext.lineScannedTo;
-  if (grammarTrivia !== void 0) {
-    ctx.trivia = grammarTrivia;
-    if (grammarTrivia._meta.triviaKindLabels) ctx.triviaKindLabels = grammarTrivia._meta.triviaKindLabels;
+function encodeForRun(ruleMap, opts) {
+  runDuplicationDiagnosticRules(ruleMap, opts.duplication);
+  const encodeMap = withAmbient(ruleMap, opts);
+  const plan = opts.coverage === true ? buildGrammarPlan(
+    encodeMap.map(([, rule2]) => rule2),
+    Object.fromEntries(encodeMap.filter(([, rule2]) => rule2._def.tag !== "lazy"))
+  ) : void 0;
+  const hostMode = resolveHostMode(ruleMap, opts.hostMode);
+  const settings = {
+    hostMode,
+    ...resolveTrackLines(ruleMap, opts.trackLines) ? { trackLines: true } : {},
+    ...opts.recovery === true ? { recovery: true } : {},
+    ...plan === void 0 ? {} : { coverage: plan }
+  };
+  try {
+    const { prog, fnSrcs } = encodeTableProgram(Object.fromEntries(encodeMap), settings);
+    return { prog, fnSrcs, hostMode, plan };
+  } catch (e) {
+    opts.refusals?.push(e instanceof Error ? e.message : String(e));
+    return null;
   }
-  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
-  if (_errors !== void 0) ctx._errors = _errors;
-  if (_probe !== void 0) ctx._probe = _probe;
-  const result = combinator.parse(input, 0, ctx);
-  if (!result.ok) return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-  const withErrors = _errors !== void 0 ? { ...result, errors: _errors, furthestFail: _probe?.best ?? null } : result;
-  return lineIndex ? annotateResultLines(withErrors, normalizeLineIndex(lineIndex)) : withErrors;
 }
 
 // src/compiler/linker.ts
@@ -16945,7 +18132,7 @@ function analyzeGrammarGating(grammar, opts) {
 }
 
 // src/analysis/diagnose.ts
-var isCombinator = (g) => typeof g === "object" && g !== null && "_def" in g;
+var isCombinator2 = (g) => typeof g === "object" && g !== null && "_def" in g;
 var isRuleEntries = (g) => Array.isArray(g);
 function diagnoseGrammar(grammar, opts) {
   const depth = degradationCaptureDepth();
@@ -16966,7 +18153,7 @@ function examinedNothing(d) {
   return d.summary.totalChoices === 0 && d.summary.unanalysable > 0;
 }
 function runAnalysis(grammar, opts) {
-  if (isCombinator(grammar)) return analyzeGating(grammar, opts);
+  if (isCombinator2(grammar)) return analyzeGating(grammar, opts);
   if (isRuleEntries(grammar)) return analyzeGatingRules(grammar, opts);
   return analyzeGrammarGating(grammar, opts);
 }
@@ -17725,16 +18912,16 @@ function ownSource(fn) {
   return typeof name === "string" && name.length > 0 && globalThis[name] === fn ? name : null;
 }
 function compile(target, second, third) {
-  if (!isCombinator2(target)) return compileMap(target, second);
+  if (!isCombinator3(target)) return compileMap(target, second);
   return compileRoot(target, second, third);
 }
-function isCombinator2(x) {
+function isCombinator3(x) {
   return typeof x === "object" && x !== null && typeof x.parse === "function" && "_def" in x;
 }
 function compileMap(grammar, opts = {}) {
   const entries = [];
   for (const [key, value] of Object.entries(grammar)) {
-    if (!isCombinator2(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
+    if (!isCombinator3(value)) throw new TypeError(`compile: grammar entry "${key}" is not a parser`);
     if (value._def.tag === "lazy") {
       try {
         value._def.thunk();
@@ -18048,49 +19235,6 @@ function digestValue(value, prefix = "", options) {
   return sha.digest("hex");
 }
 
-// src/combinators/attempt.ts
-function containOption(options) {
-  if (options === void 0) return false;
-  for (const key of Object.keys(options)) {
-    if (key !== "contain") throw new TypeError(`attempt(): unknown option ${JSON.stringify(key)}`);
-  }
-  if (options.contain !== void 0 && typeof options.contain !== "boolean") {
-    throw new TypeError("attempt(): `contain` must be a boolean");
-  }
-  return options.contain === true;
-}
-function attempt(parser2, options) {
-  const contain = containOption(options);
-  const guardable = parser2._meta.firstSet.kind !== "any" && !matchesEmpty(parser2);
-  let failExpected;
-  return {
-    _tag: "attempt",
-    _meta: parser2._meta,
-    _def: contain ? { tag: "attempt", parser: parser2, contain: true } : { tag: "attempt", parser: parser2 },
-    parse(input, pos, ctx) {
-      if (guardable && ctx._probe === void 0 && !ctx._tolerant && !startsFirstSet(parser2, input, pos)) {
-        if (failExpected === void 0) {
-          const e = deriveExpected(parser2);
-          failExpected = e.length > 0 ? e : [parser2._tag];
-        }
-        return { ok: false, expected: failExpected, span: { start: pos, end: pos } };
-      }
-      const mark = saveCstMark(ctx);
-      const log = ctx._triviaLog?.length;
-      const rootLog = ctx._rootTriviaLog?.length;
-      const split = ctx._columnsSplit;
-      const result = parser2.parse(input, pos, ctx);
-      if (result.ok) return result;
-      rollbackCstCapture(ctx, mark);
-      ctx._columnsSplit = split;
-      if (log !== void 0 && ctx._triviaLog && ctx._triviaLog.length !== log) ctx._triviaLog.length = log;
-      if (rootLog !== void 0 && ctx._rootTriviaLog && ctx._rootTriviaLog.length !== rootLog) ctx._rootTriviaLog.length = rootLog;
-      if (result.committed && !contain) return result;
-      return { ok: false, expected: result.expected, span: { start: pos, end: pos } };
-    }
-  };
-}
-
 // src/combinators/not.ts
 function not(combinator) {
   const meta = {