parseman 0.55.4 → 0.57.0

package/dist/plugin/index.js

@@ -163,6 +163,11 @@ function matchesEmptyBody(p, seen, resolve3) {
         return true;
       }
     }
+    // A run consumes at least its first line's prefix, and its body after that.
+    case "lines":
+      return me(d.first ?? d.prefix) && me(d.body);
+    case "columns":
+      return d.n === 0;
     default:
       return true;
   }
@@ -277,6 +282,11 @@ function firstSetBody(p, seen, resolve3, activeTrivia) {
         resolve3,
         d.clearTrivia ? null : d.triviaParser ?? activeTrivia
       );
+    // A run starts with its first line's prefix; a nullable prefix starts with anything.
+    case "lines": {
+      const opening = d.first ?? d.prefix;
+      return empties(opening) ? any() : fs3(opening);
+    }
     default:
       return p._meta.firstSet;
   }
@@ -356,12 +366,12 @@ function scalarRootOf(combinator) {
 }
 
 // src/combinators/ref.ts
-function withRuleTrivia(trivia2, ctx, run) {
+function withRuleTrivia(trivia2, ctx, run2) {
   const savedLabels = ctx.triviaKindLabels;
   ctx.trivia = trivia2;
   ctx.triviaKindLabels = trivia2._meta.triviaKindLabels;
   try {
-    return run();
+    return run2();
   } finally {
     ctx.trivia = void 0;
     ctx.triviaKindLabels = savedLabels;
@@ -786,6 +796,8 @@ function createParseContext() {
     _triviaCaptureMask: void 0,
     trackLines: false,
     state: void 0,
+    lineView: void 0,
+    _columnsSplit: void 0,
     build: void 0,
     _errors: void 0,
     _tolerant: void 0,
@@ -804,6 +816,7 @@ function createParseContext() {
     _rootTriviaKindIndex: void 0,
     _rootTriviaStrictScopes: void 0,
     _rootTriviaCapture: void 0,
+    _gap: void 0,
     _cstTriviaLog: void 0,
     _fields: void 0,
     _cstBuf: void 0,
@@ -857,6 +870,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;
@@ -1403,7 +1417,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) {
@@ -1726,6 +1743,9 @@ function childrenOf(def) {
       ];
     case "routed":
       return def.fallback ? [def.fallback] : [];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
+    case "columns":
     case "literal":
     case "regex":
     case "keywords":
@@ -2577,11 +2597,12 @@ function parseTriviaNoCapture(triviaP, input, cur, ctx) {
   return result;
 }
 function saveLookaheadMark(ctx) {
-  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null };
+  return { ...saveTriviaMark(ctx), probeBest: ctx._probe ? ctx._probe.best : null, split: ctx._columnsSplit };
 }
 function rollbackLookahead(ctx, mark) {
   rollbackTrivia(ctx, mark);
   if (ctx._probe) ctx._probe.best = mark.probeBest;
+  ctx._columnsSplit = mark.split;
 }
 function scanWithLabels(input, cur, ctx) {
   const triviaP = ctx.trivia;
@@ -2815,8 +2836,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;
@@ -3169,6 +3232,7 @@ function matchesAt(sentinel, input, pos, ctx) {
 function captureError(ctx, error) {
   if (cstCaptureActive(ctx)) pushCstChild(ctx, error, error);
 }
+var REC = { scan: recoverScan, at: matchesAt, or: orSentinel, sentinel: firstSetSentinel, capture: captureError };
 
 // src/combinators/adjacency.ts
 function adjacencyOf(p) {
@@ -3427,6 +3491,12 @@ function derive(c, seen) {
       return deriveExpected2(def.parser);
     case "expect":
       return def.expected;
+    case "lines": {
+      const opening = def.first ?? def.prefix;
+      return matchesEmpty(opening) ? [...deriveExpected2(opening), ...deriveExpected2(def.body)] : deriveExpected2(opening);
+    }
+    case "columns":
+      return [`columns(${def.n})`];
     case "node":
     case "grammar":
     case "trivia":
@@ -3611,9 +3681,11 @@ function choice(...args) {
       for (let i = 0; i < parsers.length; i++) {
         if (gates[i] && !gates[i](ctx.state)) continue;
         const mark = saveTriviaMark(ctx);
+        const split = ctx._columnsSplit;
         const result = parsers[i].parse(input, pos, ctx);
         if (!result.ok) {
           rollbackTrivia(ctx, mark);
+          ctx._columnsSplit = split;
           const at = result.span.start;
           if (at > expectedAt) {
             expectedAt = at;
@@ -3834,6 +3906,9 @@ function parserUsesRouted(parser2, seen = /* @__PURE__ */ new Set()) {
       return parserUsesRouted(def.sentinel, seen) || def.skip.some((entry) => parserUsesRouted(entry, seen)) || def.recoverAt !== void 0 && parserUsesRouted(def.recoverAt, seen) || def.stopAt !== void 0 && parserUsesRouted(def.stopAt, seen);
     case "recover":
       return parserUsesRouted(def.parser, seen) || parserUsesRouted(def.sentinel, seen);
+    // The body parses its own input, so only the checks on this one can reuse a routed head.
+    case "lines":
+      return [def.prefix, def.first, def.lazy].some((entry) => entry !== void 0 && parserUsesRouted(entry, seen));
     case "lazy":
       try {
         return parserUsesRouted(def.thunk(), seen);
@@ -4084,9 +4159,11 @@ function attempt(parser2, options) {
       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;
@@ -4601,12 +4678,12 @@ function beginCompileDegradationDrain() {
       return true;
     });
     if (fresh.length === 0) return;
-    const lines = formatDegradations(fresh);
+    const lines2 = formatDegradations(fresh);
     if (resolveDegradationLevel() === "error") {
       throw new Error(`parseman: ${fresh.length} degraded compilation path(s)
-${lines.join("\n")}`);
+${lines2.join("\n")}`);
     }
-    for (const l of lines) console.warn(l);
+    for (const l of lines2) console.warn(l);
   };
 }
 
@@ -4792,7 +4869,7 @@ function confirmedArityForDef(def) {
     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`,
+    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;
@@ -4853,6 +4930,8 @@ function parserHasOwnFields(p, seen = /* @__PURE__ */ new Set()) {
       return parserHasOwnFields(d.sentinel, seen) || d.skip.some((x) => parserHasOwnFields(x, seen)) || d.recoverAt !== void 0 && parserHasOwnFields(d.recoverAt, seen) || d.stopAt !== void 0 && parserHasOwnFields(d.stopAt, seen);
     case "recover":
       return parserHasOwnFields(d.parser, seen) || parserHasOwnFields(d.sentinel, seen);
+    case "lines":
+      return parserHasOwnFields(d.body, seen);
     case "routed":
       return d.fallback ? parserHasOwnFields(d.fallback, seen) : false;
     case "many":
@@ -4947,7 +5026,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);
@@ -4988,12 +5067,11 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       ctx._triviaCaptureMask = savedMask;
       const { children: children3, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const 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 && children3.length === 1 ? unwrapChild(children3[0]) : collapse && children3.length === 1 ? children3[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children3.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children3[0], children3, rawChildren) ? children3[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children3, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, hostState, tags) : build(children3, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children3 };
+      const built = unwrap && children3.length === 1 ? unwrapChild(children3[0]) : collapse && children3.length === 1 ? children3[0] : (cstOutput || !build && project === void 0) && ctx.build?._parsemanCstCollapse && children3.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children3[0], children3, rawChildren) ? children3[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, ctx.state, tags) : projectChild(children3, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, ctx.state, tags) : build(children3, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children3, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children3 };
       const rawEntry2 = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry2);
@@ -5266,1100 +5344,521 @@ function sourceLeaf(root, fn) {
   return makeLeaf(root, fn, true);
 }
 
-// src/analysis/gating.ts
-function childrenOf2(d) {
-  switch (d.tag) {
-    case "sequence":
-    case "choice":
-      return d.parsers;
-    case "dispatch":
-      return [
-        d.selector,
-        ...d.cases.map((c) => c.parser),
-        ...d.matchers ? d.matchers.map((c) => c.parser) : [],
-        ...d.otherwise === void 0 ? [] : [d.otherwise]
-      ];
-    case "sepBy":
-      return [d.parser, d.separator];
-    case "recover":
-      return [d.parser, d.sentinel];
-    case "scanTo":
-      return [
-        d.sentinel,
-        ...d.skip,
-        ...d.recoverAt === void 0 ? [] : [d.recoverAt],
-        ...d.stopAt === void 0 ? [] : [d.stopAt]
-      ];
-    case "grammar":
-      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
-    case "routed":
-      return d.fallback ? [d.fallback] : [];
-    // A `lazy` is a REFERENCE, not a subtree. Descending through it would make
-    // every rule's walk cover the whole reachable grammar — site paths become
-    // nonsense, and a structural hash includes half the grammar. Treated as a
-    // leaf, keyed by the rule name it refers to, which is also the right
-    // semantics: two productions referencing `g.Ident` really do fill that slot
-    // the same way.
-    case "lazy":
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "guard":
-    case "adjacency":
-    case "unknown":
-      return [];
-    default: {
-      const rec = d;
-      return rec.parser ? [rec.parser] : [];
-    }
+// src/table/lex-body.ts
+function buildLexBodyRecognizer(spec, constants) {
+  const raw = constants[spec[0]];
+  if (!(raw instanceof RegExp)) {
+    throw new TypeError("table lexical body does not reference a RegExp constant");
   }
-}
-var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
-function firstSetToString(fs3) {
-  if (fs3.kind === "any") return "ANY";
-  if (fs3.kind === "empty") return "(empty)";
-  return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
+    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
+  }
+  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, "")}y`);
+  const suffix = spec[1];
+  return (input, pos) => {
+    re.lastIndex = pos;
+    if (!re.test(input)) return -1;
+    const end = re.lastIndex;
+    if (suffix < 0) return end * 2;
+    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2;
+  };
 }
 
-// src/analysis/commitment.ts
-function mayFail(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return true;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "literal":
-      return d.value.length > 0;
-    case "trivia":
-      return false;
-    // `optional`/`many`/a min-0 `sepBy` swallow an ORDINARY failure — zero
-    // repetitions is a match. They do NOT swallow a COMMITTED one: a dispatch
-    // that has selected an arm and then failed inside it breaks out past every
-    // enclosing repeat, straight to the fallible boundary. So these are total
-    // exactly when their body cannot commit. (Measured: treating them as
-    // unconditionally total left an extra zero-width leaf in
-    // `BareInterpolatedSelector` on benchmark.less — a rollback the legacy
-    // build fired and this one had deleted.)
-    case "optional":
-    case "many":
-      return mayCommitFailure(d.parser);
-    case "sepBy":
-      return d.min >= 1 ? mayFail(d.parser, seen) : mayCommitFailure(d.parser) || mayCommitFailure(d.separator);
-    case "oneOrMore":
-      return mayFail(d.parser, seen);
-    case "sequence":
-      return d.parsers.some((x) => mayFail(x, seen));
-    // Delegating wrappers: as fallible as what they wrap.
-    case "node":
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-    case "token":
-    case "leaf":
-      return mayFail(d.parser, seen);
-    case "lazy": {
-      try {
-        return mayFail(d.thunk(), seen);
-      } catch {
-        return true;
+// src/table/lex-program.ts
+var LEX_NODE_TERMINAL = 0;
+var LEX_NODE_SEQUENCE2 = 1;
+var LEX_NODE_SEQUENCE3 = 2;
+var LEX_NODE_SEQUENCE4 = 3;
+var LEX_NODE_SEQUENCE5 = 4;
+var LEX_NODE_CHOICE2 = 5;
+var LEX_NODE_CHOICE4 = 6;
+var LEX_NODE_CHOICE8 = 7;
+var LEX_NODE_NOT = 8;
+var LEX_NODE_OPTIONAL = 9;
+function lexProgramDigest(words) {
+  let hash = 2166136261;
+  for (const word2 of words) {
+    hash ^= word2 | 0;
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash | 0;
+}
+function classHas(cls, code) {
+  if (code < 0) return false;
+  if (code < 128) return cls.ascii[code] === 1;
+  for (let i = 0; i < cls.hi.length; i += 2) {
+    if (code >= cls.hi[i] && code <= cls.hi[i + 1]) return true;
+  }
+  return false;
+}
+var committed = (ctx) => ctx._fc === true;
+function trackLexLines(ctx, input, end) {
+  let at = ctx._lineScannedTo ?? 0;
+  const starts = ctx._lineStarts;
+  if (starts === void 0 || end <= at) return;
+  while (at < end) {
+    if (input.charCodeAt(at) === 10) starts.push(at + 1);
+    at++;
+  }
+  ctx._lineScannedTo = end;
+}
+function terminalNode(matcher, failure, tracksLines) {
+  const match = (input, pos) => {
+    const result = matcher(input, pos);
+    return result < 0 ? -1 : result / 2;
+  };
+  return {
+    match,
+    run: (input, pos, ctx) => {
+      const end = match(input, pos);
+      if (end < 0) {
+        ctx._fe = pos;
+        ctx._fx = failure;
+        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+        return -1;
       }
+      if (tracksLines) trackLexLines(ctx, input, end);
+      return end;
     }
-    // An adjacency assertion is a TEST — failing is its whole job.
-    case "adjacency":
-      return true;
-    default:
-      return true;
-  }
+  };
 }
-function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    // Atomic / non-capturing-then-failing: a failure happens before any push.
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "guard":
-    // Adjacency probes with `_cap = 0` / no `commit()`: it cannot push anything.
-    case "adjacency":
-    case "not":
-    // peek(): emitted under a non-capturing probe ctx and zero-width on both
-    // outcomes, so it can never leave a partial capture behind.
-    case "peek":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "scanTo":
-    case "unknown":
-      return false;
-    // node() captures into its own private buffers and rolls them back on
-    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
-    case "node":
-      return false;
-    // choice/firstMatch already roll back each failed arm; on overall failure
-    // nothing committed remains.
-    case "choice":
-      return false;
-    case "dispatch":
-      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
-    case "attempt":
-      return false;
-    // optional never fails; many/oneOrMore only "fail" with zero captured items.
-    case "optional":
-    case "many":
-    case "oneOrMore":
-      return false;
-    // sepBy emits its own per-iteration rollback in emitSepBy.
-    case "sepBy":
-      return false;
-    // A sequence is the real case: an earlier capturing term followed by a term
-    // that can fail leaves the earlier captures buffered.
-    //
-    // BOTH halves of that sentence are load-bearing, and the second half is what
-    // this walk exists to exploit. "Some earlier term captures" alone was the old
-    // test, and it is true of very nearly every sequence in a real grammar — a
-    // sequence almost always opens with a literal or a node. The rollback is only
-    // reachable if something AFTER the capture can still fail; once the remainder
-    // is total (`optional`/`many`/trivia/a min-0 `sepBy`), the sequence has no
-    // failure path left to roll back from, and the save+restore is dead code.
-    //
-    // `captured` tracks whether anything is in the buffers yet as the scan moves
-    // left to right. Two things put it there:
-    //   - a term that captures (`capturesLeaf`/`hasNodeDef`), and
-    //   - the inter-term TRIVIA scan, which under `capturing` pushes into
-    //     `_cstRawChildren`/`_cstTriviaLog` BEFORE the term at each boundary
-    //     i >= 1. `emitSeqValues` only rewinds that push on the term's SUCCESS
-    //     path (the "matched empty, so leave the whitespace out of the span"
-    //     branch); a term that FAILS breaks straight out with the trivia still
-    //     buffered, so from boundary 1 onward the buffers are dirty regardless of
-    //     what the earlier terms did.
-    // Each term is also asked about itself: a nested sequence can leave its own
-    // partial capture behind, and its terms are emitted inline into this same
-    // block with no boundary of their own to roll them back.
-    case "sequence": {
-      const parts = d.parsers;
-      let captured = false;
-      for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (i > 0 && triviaActive) captured = true;
-        if (captured && mayFail(part)) return true;
-        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
-        if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
-      }
-      return false;
-    }
-    // Delegating wrappers: defer to the wrapped parser.
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
-    case "recover":
-      return mayLeavePartialCapture(d.parser, seen, triviaActive);
-    case "lazy": {
-      try {
-        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
-      } catch {
-        return true;
-      }
+function sequence2(a, b) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      return e0 < 0 ? -1 : b.match(input, e0);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      return b.run(input, e0, ctx);
     }
-    // Unknown shapes: be safe and keep the rollback.
-    default:
-      return true;
-  }
+  };
 }
-function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "literal":
-    case "regex":
-    case "keywords":
-    case "node":
-    case "token":
-    case "routed":
-    case "leaf":
-      return true;
-    case "not":
-    case "peek":
-    case "guard":
-    case "adjacency":
-    case "trivia":
-    case "unknown":
-      return false;
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => capturesLeaf(x, seen));
-    case "dispatch":
-      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
-    case "sepBy":
-      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
-    case "many":
-    case "oneOrMore":
-    case "optional":
-    case "attempt":
-    case "transform":
-    case "label":
-    case "field":
-    case "expect":
-    case "withCtx":
-    case "grammar":
-    case "recover":
-      return capturesLeaf(d.parser, seen);
-    case "scanTo":
-      return true;
-    case "lazy": {
-      try {
-        return capturesLeaf(d.thunk(), seen);
-      } catch {
-        return true;
-      }
+function sequence3(a, b, c) {
+  return {
+    match: (input, pos) => {
+      const e0 = a.match(input, pos);
+      if (e0 < 0) return -1;
+      const e1 = b.match(input, e0);
+      return e1 < 0 ? -1 : c.match(input, e1);
+    },
+    run: (input, pos, ctx) => {
+      const e0 = a.run(input, pos, ctx);
+      if (e0 < 0) return -1;
+      ctx._fc = false;
+      const e1 = b.run(input, e0, ctx);
+      if (e1 < 0) return -1;
+      ctx._fc = false;
+      return c.run(input, e1, ctx);
     }
-    default:
-      return true;
-  }
+  };
 }
-function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "node":
-      return true;
-    case "lazy": {
-      try {
-        return hasNodeDef(d.thunk(), seen);
-      } catch {
-        return false;
-      }
+function sequence4(a, b, c, d) {
+  const abc = sequence3(a, b, c);
+  return {
+    match: (input, pos) => {
+      const end = abc.match(input, pos);
+      return end < 0 ? -1 : d.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abc.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return d.run(input, end, ctx);
     }
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "not":
-    case "peek":
-    case "transform":
-      return hasNodeDef(d.parser, seen);
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => hasNodeDef(x, seen));
-    case "dispatch":
-      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
-    case "sepBy":
-      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
-    case "scanTo":
-      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen)) || d.recoverAt !== void 0 && hasNodeDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasNodeDef(d.stopAt, seen);
-    case "recover":
-      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
-    case "expect":
-      return hasNodeDef(d.parser, seen);
-    case "withCtx":
-      return hasNodeDef(d.parser, seen);
-    default:
-      return false;
-  }
+  };
 }
-function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
-  if (seen.has(p)) return false;
-  seen.add(p);
-  const d = p._def;
-  switch (d.tag) {
-    case "node":
-      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
-    case "lazy": {
-      try {
-        return hasDirectBuildDef(d.thunk(), seen);
-      } catch {
-        return false;
-      }
+function sequence5(a, b, c, d, e) {
+  const abcd = sequence4(a, b, c, d);
+  return {
+    match: (input, pos) => {
+      const end = abcd.match(input, pos);
+      return end < 0 ? -1 : e.match(input, end);
+    },
+    run: (input, pos, ctx) => {
+      const end = abcd.run(input, pos, ctx);
+      if (end < 0) return -1;
+      ctx._fc = false;
+      return e.run(input, end, ctx);
     }
-    case "grammar":
-    case "trivia":
-    case "token":
-    case "leaf":
-    case "label":
-    case "field":
-    case "optional":
-    case "many":
-    case "oneOrMore":
-    case "attempt":
-    case "not":
-    case "peek":
-    case "withCtx":
-    case "expect":
-    case "transform":
-      return hasDirectBuildDef(d.parser, seen);
-    case "sequence":
-    case "choice":
-      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
-    case "dispatch":
-      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
-    case "sepBy":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
-    case "scanTo":
-      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
-    case "recover":
-      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
-    case "routed":
-      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
-    default:
-      return false;
-  }
+  };
 }
-function mayCommitFailure(p, resolve3, memo = /* @__PURE__ */ new Map()) {
-  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve3), memo);
+function appendExpected(acc, values) {
+  if (values === void 0 || values.length === 0) return acc;
+  if (acc === void 0) return values.slice();
+  acc.push(...values);
+  return acc;
 }
-var NO_EDGES = [];
-function commitFailureSuccessors(p, resolve3) {
-  const d = p._def;
-  switch (d.tag) {
-    case "dispatch":
-    case "unknown":
-      return true;
-    case "choice":
-    case "sequence":
-      return d.parsers;
-    // A contained transaction reports every failure uncommitted.
-    case "attempt":
-      return d.contain === true ? NO_EDGES : [d.parser];
-    case "many":
-    case "oneOrMore":
-    case "optional":
-    case "transform":
-    case "label":
-    case "field":
-    case "grammar":
-    case "node":
-    case "token":
-    case "leaf":
-    case "withCtx":
-      return [d.parser];
-    case "sepBy":
-      return [d.parser, d.separator];
-    case "scanTo":
-      return [
-        d.sentinel,
-        ...d.skip,
-        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
-        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
-      ];
-    case "lazy": {
-      try {
-        return [d.thunk()];
-      } catch {
-        const name = p._ruleName;
-        const target = name === void 0 ? void 0 : resolve3?.(name);
-        return target === void 0 ? true : [target];
+function choiceNode(arms, classes, armExpected, choiceExpected) {
+  let matchTail = () => -1;
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], next = matchTail;
+    matchTail = (input, pos) => {
+      const end = arm.match(input, pos);
+      return end < 0 ? next(input, pos) : end;
+    };
+  }
+  let tail = (_input, pos, ctx, _lead, acc) => {
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceExpected;
+    return -1;
+  };
+  for (let i = arms.length - 1; i >= 0; i--) {
+    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
+    tail = (input, pos, ctx, lead2, acc, best) => {
+      if (cls !== void 0 && !classHas(cls, lead2)) {
+        return next(
+          input,
+          pos,
+          ctx,
+          lead2,
+          best === pos ? appendExpected(acc, staticExpected) : acc,
+          best
+        );
       }
-    }
-    default:
-      return NO_EDGES;
+      ctx._fc = false;
+      const end = arm.run(input, pos, ctx);
+      if (end >= 0) return end;
+      const at = ctx._fe ?? pos;
+      if (at > best) {
+        best = at;
+        acc = void 0;
+      }
+      const nextAcc = at === best ? appendExpected(acc, ctx._fx) : acc;
+      if (committed(ctx)) {
+        if (nextAcc !== void 0) ctx._fx = nextAcc;
+        return -1;
+      }
+      return next(input, pos, ctx, lead2, nextAcc, best);
+    };
   }
+  return {
+    match: matchTail,
+    run: (input, pos, ctx) => tail(
+      input,
+      pos,
+      ctx,
+      pos < input.length ? input.codePointAt(pos) : -1,
+      void 0,
+      pos
+    )
+  };
 }
-function reachesMarked(root, successors, memo) {
-  const known = memo.get(root);
-  if (known !== void 0) return known;
-  const order = /* @__PURE__ */ new Map();
-  const low = [];
-  const found = [];
-  const stack = [];
-  const visit = (node2) => {
-    const at = low.length;
-    order.set(node2, at);
-    low.push(at);
-    found.push(false);
-    stack.push(node2);
-    const next = successors(node2);
-    if (next === true) found[at] = true;
-    else {
-      for (const child of next) {
-        if (found[at]) break;
-        const hit = memo.get(child);
-        if (hit !== void 0) {
-          if (hit) found[at] = true;
-          continue;
-        }
-        const seen = order.get(child);
-        if (seen !== void 0) {
-          if (seen < low[at]) low[at] = seen;
-          continue;
-        }
-        const k = visit(child);
-        if (low[k] < low[at]) low[at] = low[k];
-        if (found[k]) found[at] = true;
-      }
-    }
-    if (low[at] === at) {
-      const answer = found[at];
-      let member;
-      do {
-        member = stack.pop();
-        memo.set(member, answer);
-      } while (member !== node2);
+function notNode(body, failure) {
+  return {
+    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
+    run: (input, pos, ctx) => {
+      if (body.match(input, pos) < 0) return pos;
+      ctx._fe = pos;
+      ctx._fx = failure;
+      return -1;
     }
-    return at;
   };
-  return found[visit(root)];
 }
-function hasSemanticReduction(roots, externalRefs) {
-  const seen = /* @__PURE__ */ new Set();
-  const visit = (parser2) => {
-    if (seen.has(parser2)) return false;
-    seen.add(parser2);
-    const def = parser2._def;
-    if (def.tag === "transform" && !def.recognitionOnly) return true;
-    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
-    if (def.tag === "guard" || def.tag === "withCtx") return true;
-    if (def.tag === "node" && def.build !== void 0) return true;
-    if (def.tag === "lazy") {
-      if (externalRefs?.has(parser2)) return false;
-      try {
-        return visit(def.thunk());
-      } catch {
-        return true;
-      }
+function optionalNode(body) {
+  return {
+    match: (input, pos) => {
+      const end = body.match(input, pos);
+      return end < 0 ? pos : end;
+    },
+    run: (input, pos, ctx) => {
+      ctx._fc = false;
+      const end = body.run(input, pos, ctx);
+      return end < 0 && !committed(ctx) ? pos : end;
     }
-    return childrenOf2(def).some(visit);
   };
-  return roots.some(visit);
 }
-function classifyRuleMap(ruleMap) {
-  const externalRefs = /* @__PURE__ */ new Set();
-  const scanned = /* @__PURE__ */ new Set();
-  const scanExternal = (p) => {
-    if (scanned.has(p)) return;
-    scanned.add(p);
-    const def = p._def;
-    if (def.tag === "lazy") {
-      let resolved;
-      try {
-        resolved = def.thunk();
-      } catch {
-        resolved = void 0;
+function fixedTreeRunner(words, matchers, classes, expected) {
+  const stack = [];
+  const pop = () => {
+    const value = stack.pop();
+    if (value === void 0) throw new TypeError("table lexical tree has an incomplete fixed body");
+    return value;
+  };
+  for (let at = 0; at < words.length; ) {
+    const op = words[at++];
+    if (op === LEX_NODE_TERMINAL) {
+      const matcher = matchers[words[at++]], failure = expected[words[at++]];
+      const tracks = words[at++];
+      if (matcher === void 0 || failure === void 0 || tracks !== 0 && tracks !== 1) {
+        throw new TypeError("table lexical tree terminal references an invalid pool entry");
       }
-      if (resolved === void 0) {
-        if (p._ruleName) externalRefs.add(p);
-        return;
+      stack.push(terminalNode(matcher, failure, tracks === 1));
+      continue;
+    }
+    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
+      const count = op - LEX_NODE_SEQUENCE2 + 2;
+      const nodes2 = Array.from({ length: count }, pop).reverse();
+      if (count === 2) stack.push(sequence2(nodes2[0], nodes2[1]));
+      else if (count === 3) stack.push(sequence3(nodes2[0], nodes2[1], nodes2[2]));
+      else if (count === 4) stack.push(sequence4(nodes2[0], nodes2[1], nodes2[2], nodes2[3]));
+      else stack.push(sequence5(nodes2[0], nodes2[1], nodes2[2], nodes2[3], nodes2[4]));
+      continue;
+    }
+    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
+      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
+      const choiceFx = expected[words[at++]];
+      if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
+      const armClasses = [];
+      const armFx = [];
+      for (let i = 0; i < count; i++) {
+        const cls = words[at++], fx = expected[words[at++]];
+        if (cls < -1 || cls >= 0 && classes[cls] === void 0 || fx === void 0) {
+          throw new TypeError("table lexical tree choice references an invalid pool entry");
+        }
+        armClasses.push(cls < 0 ? void 0 : classes[cls]);
+        armFx.push(fx);
       }
-      scanExternal(resolved);
-      return;
+      const arms = Array.from({ length: count }, pop).reverse();
+      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
+      continue;
     }
-    for (const child of childrenOf2(def)) scanExternal(child);
-  };
-  for (const [, rule] of ruleMap) scanExternal(rule);
-  return {
-    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
-    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
-  };
+    if (op === LEX_NODE_NOT) {
+      const failure = expected[words[at++]];
+      if (failure === void 0) throw new TypeError("table lexical tree assertion has an invalid expected set");
+      stack.push(notNode(pop(), failure));
+      continue;
+    }
+    if (op === LEX_NODE_OPTIONAL) {
+      stack.push(optionalNode(pop()));
+      continue;
+    }
+    throw new TypeError("table lexical tree has an unknown fixed body");
+  }
+  if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
+  return stack[0].run;
 }
-
-// src/table/ops.ts
-var OP_LIT = 1;
-var OP_RX = 2;
-var OP_SEQ = 3;
-var OP_SEQV = 4;
-var OP_CHOICE = 5;
-var OP_REP = 6;
-var OP_REPV = 7;
-var OP_OPT = 8;
-var OP_XFORM = 9;
-var OP_NODE = 10;
-var OP_RULE = 11;
-var OP_GATE = 12;
-var OP_NOT = 13;
-var OP_PEEK = 14;
-var OP_LEAF = 15;
-var OP_EMPTY = 16;
-var OP_LIT_TRACK = 17;
-var OP_RX_TRACK = 18;
-var OP_NODE_TRACK = 19;
-var OP_SCOPE = 20;
-var OP_EXPECT = 21;
-var OP_SEQX = 22;
-var OP_SCAN = 23;
-var OP_FIELD = 24;
-var OP_LIT_CI = 27;
-var OP_LIT_CI_TRACK = 28;
-var OP_TOKEN = 29;
-var OP_SCOPE_CAP = 30;
-var OP_WITHCTX = 31;
-var OP_GUARD = 32;
-var OP_ADJ = 33;
-var OP_GREEDY = 34;
-var OP_REJECT = 35;
-var OP_ARMGATE = 36;
-var OP_LIVE = 37;
-var OP_ATTEMPT = 38;
-var OP_LABEL = 39;
-var OP_COV = 40;
-var OP_SCOPE_PLAIN = 41;
-var OP_LEX_BODY = 42;
-var OP_LEX_PROGRAM = 43;
-var OP_SOURCE_LEAF = 44;
-var OP_DISPATCH = 25;
-var OP_ROUTED = 26;
-var OP_NAMES = {
-  [OP_LIT]: "LIT",
-  [OP_RX]: "RX",
-  [OP_SEQ]: "SEQ",
-  [OP_SEQV]: "SEQV",
-  [OP_CHOICE]: "CHOICE",
-  [OP_REP]: "REP",
-  [OP_REPV]: "REPV",
-  [OP_OPT]: "OPT",
-  [OP_XFORM]: "XFORM",
-  [OP_NODE]: "NODE",
-  [OP_RULE]: "RULE",
-  [OP_GATE]: "GATE",
-  [OP_NOT]: "NOT",
-  [OP_PEEK]: "PEEK",
-  [OP_LEAF]: "LEAF",
-  [OP_SOURCE_LEAF]: "SOURCE_LEAF",
-  [OP_EMPTY]: "EMPTY",
-  [OP_LIT_TRACK]: "LIT_TRACK",
-  [OP_RX_TRACK]: "RX_TRACK",
-  [OP_NODE_TRACK]: "NODE_TRACK",
-  [OP_SCOPE]: "SCOPE",
-  [OP_EXPECT]: "EXPECT",
-  [OP_SEQX]: "SEQX",
-  [OP_SCAN]: "SCAN",
-  [OP_FIELD]: "FIELD",
-  [OP_LIT_CI]: "LIT_CI",
-  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
-  [OP_DISPATCH]: "DISPATCH",
-  [OP_ROUTED]: "ROUTED",
-  [OP_TOKEN]: "TOKEN",
-  [OP_SCOPE_CAP]: "SCOPE_CAP",
-  [OP_WITHCTX]: "WITHCTX",
-  [OP_GUARD]: "GUARD",
-  [OP_ADJ]: "ADJ",
-  [OP_GREEDY]: "GREEDY",
-  [OP_REJECT]: "REJECT",
-  [OP_ARMGATE]: "ARMGATE",
-  [OP_LIVE]: "LIVE",
-  [OP_ATTEMPT]: "ATTEMPT",
-  [OP_LABEL]: "LABEL",
-  [OP_COV]: "COV",
-  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
-  [OP_LEX_BODY]: "LEX_BODY",
-  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
-};
-
-// src/table/lex-program.ts
-var LEX_NODE_TERMINAL = 0;
-var LEX_NODE_SEQUENCE2 = 1;
-var LEX_NODE_SEQUENCE3 = 2;
-var LEX_NODE_SEQUENCE4 = 3;
-var LEX_NODE_SEQUENCE5 = 4;
-var LEX_NODE_CHOICE2 = 5;
-var LEX_NODE_CHOICE4 = 6;
-var LEX_NODE_CHOICE8 = 7;
-var LEX_NODE_NOT = 8;
-var LEX_NODE_OPTIONAL = 9;
-function lexProgramDigest(words) {
-  let hash = 2166136261;
-  for (const word2 of words) {
-    hash ^= word2 | 0;
-    hash = Math.imul(hash, 16777619);
+function buildLexProgramRunner(spec, matchers, classes, expected) {
+  if (spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3 || spec[0] === 0 && spec.length !== 13 || spec[0] === 1 && spec.length !== 12 || spec[0] === 2 && spec.length < 6 || spec[0] === 3 && spec.length !== 3) {
+    throw new TypeError("table lexical program has an invalid fixed body width");
   }
-  return hash | 0;
-}
-function classHas(cls, code) {
-  if (code < 0) return false;
-  if (code < 128) return cls.ascii[code] === 1;
-  for (let i = 0; i < cls.hi.length; i += 2) {
-    if (code >= cls.hi[i] && code <= cls.hi[i + 1]) return true;
+  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
+    throw new TypeError("table lexical program semantic digest is inconsistent");
   }
-  return false;
-}
-var committed = (ctx) => ctx._fc === true;
-function trackLexLines(ctx, input, end) {
-  let at = ctx._lineScannedTo ?? 0;
-  const starts = ctx._lineStarts;
-  if (starts === void 0 || end <= at) return;
-  while (at < end) {
-    if (input.charCodeAt(at) === 10) starts.push(at + 1);
-    at++;
+  if (spec[0] === 3) {
+    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
+      throw new TypeError("table balanced lexical program has an invalid scan reference");
+    }
+    const run2 = (_input, _pos, ctx, scan) => {
+      if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
+      const result = scan.parse(_input, _pos, ctx);
+      if (!result.ok) {
+        ctx._fe = result.span.start;
+        ctx._fx = result.expected ?? [];
+        return -1;
+      }
+      return result.span.end;
+    };
+    return Object.assign(run2, { scan: spec[2] });
   }
-  ctx._lineScannedTo = end;
-}
-function terminalNode(matcher, failure, tracksLines) {
-  const match = (input, pos) => {
-    const result = matcher(input, pos);
-    return result < 0 ? -1 : result / 2;
-  };
-  return {
-    match,
-    run: (input, pos, ctx) => {
-      const end = match(input, pos);
-      if (end < 0) {
+  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
+  if (spec[0] === 1) {
+    const g00 = matchers[spec[2]], g01 = matchers[spec[3]];
+    const g02 = matchers[spec[4]], g03 = matchers[spec[5]];
+    const guard0Fx = expected[spec[6]];
+    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]];
+    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]];
+    const tracks2 = spec[11];
+    if (g00 === void 0 || g01 === void 0 || g02 === void 0 || g03 === void 0 || guard0Fx === void 0 || g1 === void 0 || guard1Fx === void 0 || terminal === void 0 || terminalFx === void 0 || tracks2 !== 0 && tracks2 !== 1) {
+      throw new TypeError("table lexical program references an invalid pool entry");
+    }
+    return (input, pos, ctx) => {
+      ctx._fc = false;
+      if (g00(input, pos) >= 0 || g01(input, pos) >= 0 || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
         ctx._fe = pos;
-        ctx._fx = failure;
+        ctx._fx = guard0Fx;
+        return -1;
+      }
+      ctx._fc = false;
+      if (g1(input, pos) >= 0) {
+        ctx._fe = pos;
+        ctx._fx = guard1Fx;
+        return -1;
+      }
+      ctx._fc = false;
+      const result = terminal(input, pos);
+      if (result < 0) {
+        ctx._fe = pos;
+        ctx._fx = terminalFx;
         if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
         return -1;
       }
-      if (tracksLines) trackLexLines(ctx, input, end);
+      const end = result / 2;
+      if (tracks2 === 1) trackLexLines(ctx, input, end);
       return end;
+    };
+  }
+  const cls = classes[spec[2]];
+  const choiceFx = expected[spec[3]];
+  const m0 = matchers[spec[4]], x0 = expected[spec[5]];
+  const m1 = matchers[spec[6]], x1 = expected[spec[7]];
+  const m2 = matchers[spec[8]], x2 = expected[spec[9]];
+  const m3 = matchers[spec[10]], x3 = expected[spec[11]];
+  const tracks = spec[12];
+  if (cls === void 0 || choiceFx === void 0 || m0 === void 0 || x0 === void 0 || m1 === void 0 || x1 === void 0 || m2 === void 0 || x2 === void 0 || m3 === void 0 || x3 === void 0 || tracks !== 0 && tracks !== 1) {
+    throw new TypeError("table lexical program references an invalid pool entry");
+  }
+  return (input, pos, ctx) => {
+    const lead2 = pos < input.length ? input.codePointAt(pos) : -1;
+    if (!classHas(cls, lead2)) {
+      ctx._fe = pos;
+      ctx._fx = choiceFx.slice();
+      return -1;
     }
+    let acc;
+    const failed = (fx) => {
+      ctx._fe = pos;
+      ctx._fx = fx;
+      if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
+      if (acc === void 0) acc = fx.slice();
+      else acc.push(...fx);
+    };
+    ctx._fc = false;
+    const success = (result2) => {
+      const end = result2 / 2;
+      if (tracks === 1) trackLexLines(ctx, input, end);
+      return end;
+    };
+    let result = m0(input, pos);
+    if (result >= 0) return success(result);
+    failed(x0);
+    ctx._fc = false;
+    result = m1(input, pos);
+    if (result >= 0) return success(result);
+    failed(x1);
+    ctx._fc = false;
+    result = m2(input, pos);
+    if (result >= 0) return success(result);
+    failed(x2);
+    ctx._fc = false;
+    result = m3(input, pos);
+    if (result >= 0) return success(result);
+    failed(x3);
+    ctx._fe = pos;
+    ctx._fx = acc ?? choiceFx;
+    return -1;
   };
 }
-function sequence2(a, b) {
-  return {
-    match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      return e0 < 0 ? -1 : b.match(input, e0);
-    },
-    run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
-      if (e0 < 0) return -1;
-      ctx._fc = false;
-      return b.run(input, e0, ctx);
-    }
-  };
+
+// src/table/program.ts
+function closureArtifact(prog) {
+  return { ...prog, asm: [] };
 }
-function sequence3(a, b, c) {
-  return {
-    match: (input, pos) => {
-      const e0 = a.match(input, pos);
-      if (e0 < 0) return -1;
-      const e1 = b.match(input, e0);
-      return e1 < 0 ? -1 : c.match(input, e1);
-    },
-    run: (input, pos, ctx) => {
-      const e0 = a.run(input, pos, ctx);
-      if (e0 < 0) return -1;
-      ctx._fc = false;
-      const e1 = b.run(input, e0, ctx);
-      if (e1 < 0) return -1;
-      ctx._fc = false;
-      return c.run(input, e1, ctx);
-    }
-  };
+function covKindCode(kind) {
+  switch (kind) {
+    case "rule":
+      return 0;
+    case "choice-arm":
+      return 1;
+    case "dispatch-arm":
+      return 2;
+    case "label":
+      return 3;
+  }
 }
-function sequence4(a, b, c, d) {
-  const abc = sequence3(a, b, c);
-  return {
-    match: (input, pos) => {
-      const end = abc.match(input, pos);
-      return end < 0 ? -1 : d.match(input, end);
-    },
-    run: (input, pos, ctx) => {
-      const end = abc.run(input, pos, ctx);
-      if (end < 0) return -1;
-      ctx._fc = false;
-      return d.run(input, end, ctx);
-    }
-  };
+function covKindName(code) {
+  switch (code) {
+    case 0:
+      return "rule";
+    case 1:
+      return "choice-arm";
+    case 2:
+      return "dispatch-arm";
+    case 3:
+      return "label";
+  }
 }
-function sequence5(a, b, c, d, e) {
-  const abcd = sequence4(a, b, c, d);
-  return {
-    match: (input, pos) => {
-      const end = abcd.match(input, pos);
-      return end < 0 ? -1 : e.match(input, end);
-    },
-    run: (input, pos, ctx) => {
-      const end = abcd.run(input, pos, ctx);
-      if (end < 0) return -1;
-      ctx._fc = false;
-      return e.run(input, end, ctx);
-    }
-  };
+function covDefinitions(prog) {
+  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
 }
-function appendExpected(acc, values) {
-  if (values === void 0 || values.length === 0) return acc;
-  if (acc === void 0) return values.slice();
-  acc.push(...values);
-  return acc;
+function scanRefs(s) {
+  const refs = [];
+  for (const r of [s.sentinel, s.recoverAt, s.stopAt, s.prefix, s.body, s.first, s.lazy]) if (r !== void 0) refs.push(r);
+  refs.push(...s.skip);
+  return refs;
 }
-function choiceNode(arms, classes, armExpected, choiceExpected) {
-  let matchTail = () => -1;
-  for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], next = matchTail;
-    matchTail = (input, pos) => {
-      const end = arm.match(input, pos);
-      return end < 0 ? next(input, pos) : end;
-    };
-  }
-  let tail = (_input, pos, ctx, _lead, acc) => {
-    ctx._fe = pos;
-    ctx._fx = acc ?? choiceExpected;
-    return -1;
+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({
+    code: p.c,
+    k: p.k,
+    cc: p.x,
+    fx: p.e,
+    disp: p.d,
+    rules: p.r,
+    fns: p.f,
+    lines: p.l ?? 0,
+    dsp: p.p ?? [],
+    ...p.lx === void 0 ? {} : { lex: p.lx },
+    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
+    ...p.lb === void 0 ? {} : { labels: p.lb },
+    ...p.rc === void 0 ? {} : { classified: p.rc },
+    ...p.h === void 0 ? {} : { hostMode: p.h },
+    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
+    ...p.sc === void 0 ? {} : { scans: p.sc },
+    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
+    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
+    ...p.rv === void 0 ? {} : { rec: p.rv },
+    ...p.cv === void 0 ? {} : { cov: p.cv },
+    ...p.a === void 0 ? {} : { asm: p.a }
+  });
+}
+function validateDispatchSpec(spec, arity, fallbackRouted) {
+  const invalid = (arms) => {
+    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
+    return false;
   };
-  for (let i = arms.length - 1; i >= 0; i--) {
-    const arm = arms[i], cls = classes[i], staticExpected = armExpected[i], next = tail;
-    tail = (input, pos, ctx, lead2, acc, best) => {
-      if (cls !== void 0 && !classHas(cls, lead2)) {
-        return next(
-          input,
-          pos,
-          ctx,
-          lead2,
-          best === pos ? appendExpected(acc, staticExpected) : acc,
-          best
-        );
-      }
-      ctx._fc = false;
-      const end = arm.run(input, pos, ctx);
-      if (end >= 0) return end;
-      const at = ctx._fe ?? pos;
-      if (at > best) {
-        best = at;
-        acc = void 0;
-      }
-      const nextAcc = at === best ? appendExpected(acc, ctx._fx) : acc;
-      if (committed(ctx)) {
-        if (nextAcc !== void 0) ctx._fx = nextAcc;
-        return -1;
-      }
-      return next(input, pos, ctx, lead2, nextAcc, best);
-    };
+  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
+    throw new TypeError("table: malformed dispatch");
   }
-  return {
-    match: matchTail,
-    run: (input, pos, ctx) => tail(
-      input,
-      pos,
-      ctx,
-      pos < input.length ? input.codePointAt(pos) : -1,
-      void 0,
-      pos
-    )
-  };
 }
-function notNode(body, failure) {
+var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
+function ownTableProgram(prog, resolved, caches = {}) {
+  const runtime = prog[TABLE_RUNTIME];
   return {
-    match: (input, pos) => body.match(input, pos) < 0 ? pos : -1,
-    run: (input, pos, ctx) => {
-      if (body.match(input, pos) < 0) return pos;
-      ctx._fe = pos;
-      ctx._fx = failure;
-      return -1;
+    ...prog,
+    [TABLE_RUNTIME]: {
+      resolved,
+      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
+      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
+      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
     }
   };
 }
-function optionalNode(body) {
-  return {
-    match: (input, pos) => {
-      const end = body.match(input, pos);
-      return end < 0 ? pos : end;
-    },
-    run: (input, pos, ctx) => {
-      ctx._fc = false;
-      const end = body.run(input, pos, ctx);
-      return end < 0 && !committed(ctx) ? pos : end;
-    }
-  };
+function choiceRollbackMask(prog, ip) {
+  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
 }
-function fixedTreeRunner(words, matchers, classes, expected) {
-  const stack = [];
-  const pop = () => {
-    const value = stack.pop();
-    if (value === void 0) throw new TypeError("table lexical tree has an incomplete fixed body");
-    return value;
-  };
-  for (let at = 0; at < words.length; ) {
-    const op = words[at++];
-    if (op === LEX_NODE_TERMINAL) {
-      const matcher = matchers[words[at++]], failure = expected[words[at++]];
-      const tracks = words[at++];
-      if (matcher === void 0 || failure === void 0 || tracks !== 0 && tracks !== 1) {
-        throw new TypeError("table lexical tree terminal references an invalid pool entry");
-      }
-      stack.push(terminalNode(matcher, failure, tracks === 1));
-      continue;
-    }
-    if (op >= LEX_NODE_SEQUENCE2 && op <= LEX_NODE_SEQUENCE5) {
-      const count = op - LEX_NODE_SEQUENCE2 + 2;
-      const nodes2 = Array.from({ length: count }, pop).reverse();
-      if (count === 2) stack.push(sequence2(nodes2[0], nodes2[1]));
-      else if (count === 3) stack.push(sequence3(nodes2[0], nodes2[1], nodes2[2]));
-      else if (count === 4) stack.push(sequence4(nodes2[0], nodes2[1], nodes2[2], nodes2[3]));
-      else stack.push(sequence5(nodes2[0], nodes2[1], nodes2[2], nodes2[3], nodes2[4]));
-      continue;
-    }
-    if (op >= LEX_NODE_CHOICE2 && op <= LEX_NODE_CHOICE8) {
-      const count = op === LEX_NODE_CHOICE2 ? 2 : op === LEX_NODE_CHOICE4 ? 4 : 8;
-      const choiceFx = expected[words[at++]];
-      if (choiceFx === void 0) throw new TypeError("table lexical tree choice has an invalid expected set");
-      const armClasses = [];
-      const armFx = [];
-      for (let i = 0; i < count; i++) {
-        const cls = words[at++], fx = expected[words[at++]];
-        if (cls < -1 || cls >= 0 && classes[cls] === void 0 || fx === void 0) {
-          throw new TypeError("table lexical tree choice references an invalid pool entry");
-        }
-        armClasses.push(cls < 0 ? void 0 : classes[cls]);
-        armFx.push(fx);
-      }
-      const arms = Array.from({ length: count }, pop).reverse();
-      stack.push(choiceNode(arms, armClasses, armFx, choiceFx));
-      continue;
-    }
-    if (op === LEX_NODE_NOT) {
-      const failure = expected[words[at++]];
-      if (failure === void 0) throw new TypeError("table lexical tree assertion has an invalid expected set");
-      stack.push(notNode(pop(), failure));
-      continue;
-    }
-    if (op === LEX_NODE_OPTIONAL) {
-      stack.push(optionalNode(pop()));
-      continue;
+function choiceCannotCommit(prog, ip) {
+  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
+}
+function failureRollbackClean(prog, ip) {
+  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
+}
+var WIDE_CLASS_PREFIX_LO = 65535;
+var WIDE_CLASS_PREFIX_HI = 0;
+function validateClassRange(lo, hi) {
+  for (const cp of [lo, hi]) {
+    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
     }
-    throw new TypeError("table lexical tree has an unknown fixed body");
   }
-  if (stack.length !== 1) throw new TypeError("table lexical tree does not resolve to one root body");
-  return stack[0].run;
+  if (lo > hi) {
+    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+  }
 }
-function buildLexProgramRunner(spec, matchers, classes, expected) {
-  if (spec[0] !== 0 && spec[0] !== 1 && spec[0] !== 2 && spec[0] !== 3 || spec[0] === 0 && spec.length !== 13 || spec[0] === 1 && spec.length !== 12 || spec[0] === 2 && spec.length < 6 || spec[0] === 3 && spec.length !== 3) {
-    throw new TypeError("table lexical program has an invalid fixed body width");
-  }
-  if (spec[1] !== lexProgramDigest(spec.slice(2))) {
-    throw new TypeError("table lexical program semantic digest is inconsistent");
-  }
-  if (spec[0] === 3) {
-    if (!Number.isInteger(spec[2]) || spec[2] < 0) {
-      throw new TypeError("table balanced lexical program has an invalid scan reference");
-    }
-    const run = (_input, _pos, ctx, scan) => {
-      if (scan === void 0) throw new TypeError("table balanced lexical program lost its scan body");
-      const result = scan.parse(_input, _pos, ctx);
-      if (!result.ok) {
-        ctx._fe = result.span.start;
-        ctx._fx = result.expected ?? [];
-        return -1;
-      }
-      return result.span.end;
-    };
-    return Object.assign(run, { scan: spec[2] });
-  }
-  if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
-  if (spec[0] === 1) {
-    const g00 = matchers[spec[2]], g01 = matchers[spec[3]];
-    const g02 = matchers[spec[4]], g03 = matchers[spec[5]];
-    const guard0Fx = expected[spec[6]];
-    const g1 = matchers[spec[7]], guard1Fx = expected[spec[8]];
-    const terminal = matchers[spec[9]], terminalFx = expected[spec[10]];
-    const tracks2 = spec[11];
-    if (g00 === void 0 || g01 === void 0 || g02 === void 0 || g03 === void 0 || guard0Fx === void 0 || g1 === void 0 || guard1Fx === void 0 || terminal === void 0 || terminalFx === void 0 || tracks2 !== 0 && tracks2 !== 1) {
-      throw new TypeError("table lexical program references an invalid pool entry");
-    }
-    return (input, pos, ctx) => {
-      ctx._fc = false;
-      if (g00(input, pos) >= 0 || g01(input, pos) >= 0 || g02(input, pos) >= 0 || g03(input, pos) >= 0) {
-        ctx._fe = pos;
-        ctx._fx = guard0Fx;
-        return -1;
-      }
-      ctx._fc = false;
-      if (g1(input, pos) >= 0) {
-        ctx._fe = pos;
-        ctx._fx = guard1Fx;
-        return -1;
-      }
-      ctx._fc = false;
-      const result = terminal(input, pos);
-      if (result < 0) {
-        ctx._fe = pos;
-        ctx._fx = terminalFx;
-        if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
-        return -1;
-      }
-      const end = result / 2;
-      if (tracks2 === 1) trackLexLines(ctx, input, end);
-      return end;
-    };
-  }
-  const cls = classes[spec[2]];
-  const choiceFx = expected[spec[3]];
-  const m0 = matchers[spec[4]], x0 = expected[spec[5]];
-  const m1 = matchers[spec[6]], x1 = expected[spec[7]];
-  const m2 = matchers[spec[8]], x2 = expected[spec[9]];
-  const m3 = matchers[spec[10]], x3 = expected[spec[11]];
-  const tracks = spec[12];
-  if (cls === void 0 || choiceFx === void 0 || m0 === void 0 || x0 === void 0 || m1 === void 0 || x1 === void 0 || m2 === void 0 || x2 === void 0 || m3 === void 0 || x3 === void 0 || tracks !== 0 && tracks !== 1) {
-    throw new TypeError("table lexical program references an invalid pool entry");
-  }
-  return (input, pos, ctx) => {
-    const lead2 = pos < input.length ? input.codePointAt(pos) : -1;
-    if (!classHas(cls, lead2)) {
-      ctx._fe = pos;
-      ctx._fx = choiceFx.slice();
-      return -1;
-    }
-    let acc;
-    const failed = (fx) => {
-      ctx._fe = pos;
-      ctx._fx = fx;
-      if (ctx._probe !== void 0) failAt(ctx, ctx._fx, pos);
-      if (acc === void 0) acc = fx.slice();
-      else acc.push(...fx);
-    };
-    ctx._fc = false;
-    const success = (result2) => {
-      const end = result2 / 2;
-      if (tracks === 1) trackLexLines(ctx, input, end);
-      return end;
-    };
-    let result = m0(input, pos);
-    if (result >= 0) return success(result);
-    failed(x0);
-    ctx._fc = false;
-    result = m1(input, pos);
-    if (result >= 0) return success(result);
-    failed(x1);
-    ctx._fc = false;
-    result = m2(input, pos);
-    if (result >= 0) return success(result);
-    failed(x2);
-    ctx._fc = false;
-    result = m3(input, pos);
-    if (result >= 0) return success(result);
-    failed(x3);
-    ctx._fe = pos;
-    ctx._fx = acc ?? choiceFx;
-    return -1;
-  };
-}
-
-// src/table/lex-body.ts
-function buildLexBodyRecognizer(spec, constants) {
-  const raw = constants[spec[0]];
-  if (!(raw instanceof RegExp)) {
-    throw new TypeError("table lexical body does not reference a RegExp constant");
-  }
-  if (!Number.isInteger(spec[1]) || spec[1] < -1 || spec[1] > 65535) {
-    throw new TypeError("table lexical body suffix is not absent or one UTF-16 code unit");
-  }
-  const re = raw.sticky ? new RegExp(raw.source, raw.flags) : new RegExp(raw.source, `${raw.flags.replace(/[gy]/g, "")}y`);
-  const suffix = spec[1];
-  return (input, pos) => {
-    re.lastIndex = pos;
-    if (!re.test(input)) return -1;
-    const end = re.lastIndex;
-    if (suffix < 0) return end * 2;
-    return input.charCodeAt(end) === suffix ? (end + 1) * 2 + 1 : end * 2;
-  };
-}
-
-// src/table/program.ts
-function closureArtifact(prog) {
-  return { ...prog, asm: [] };
-}
-function covKindCode(kind) {
-  switch (kind) {
-    case "rule":
-      return 0;
-    case "choice-arm":
-      return 1;
-    case "dispatch-arm":
-      return 2;
-    case "label":
-      return 3;
-  }
-}
-function covKindName(code) {
-  switch (code) {
-    case 0:
-      return "rule";
-    case 1:
-      return "choice-arm";
-    case 2:
-      return "dispatch-arm";
-    case 3:
-      return "label";
-  }
-}
-function covDefinitions(prog) {
-  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
-}
-function expandCompact(p) {
-  if ("code" in p) return p;
-  return ownTableProgram({
-    code: p.c,
-    k: p.k,
-    cc: p.x,
-    fx: p.e,
-    disp: p.d,
-    rules: p.r,
-    fns: p.f,
-    lines: p.l ?? 0,
-    dsp: p.p ?? [],
-    ...p.lx === void 0 ? {} : { lex: p.lx },
-    ...p.lp === void 0 ? {} : { lexPrograms: p.lp },
-    ...p.lb === void 0 ? {} : { labels: p.lb },
-    ...p.rc === void 0 ? {} : { classified: p.rc },
-    ...p.h === void 0 ? {} : { hostMode: p.h },
-    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
-    ...p.sc === void 0 ? {} : { scans: p.sc },
-    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
-    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
-    ...p.rv === void 0 ? {} : { rec: p.rv },
-    ...p.cv === void 0 ? {} : { cov: p.cv },
-    ...p.a === void 0 ? {} : { asm: p.a }
-  });
-}
-function validateDispatchSpec(spec, arity, fallbackRouted) {
-  const invalid = (arms) => {
-    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
-    return false;
-  };
-  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
-    throw new TypeError("table: malformed dispatch");
-  }
-}
-var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
-function ownTableProgram(prog, resolved, caches = {}) {
-  const runtime = prog[TABLE_RUNTIME];
-  return {
-    ...prog,
-    [TABLE_RUNTIME]: {
-      resolved,
-      choiceRollbackMasks: caches.choiceRollbackMasks ?? runtime?.choiceRollbackMasks,
-      nonCommittingChoiceSites: caches.nonCommittingChoiceSites ?? runtime?.nonCommittingChoiceSites,
-      failureRollbackCleanSites: caches.failureRollbackCleanSites ?? runtime?.failureRollbackCleanSites
-    }
-  };
-}
-function choiceRollbackMask(prog, ip) {
-  return prog[TABLE_RUNTIME]?.choiceRollbackMasks?.get(ip);
-}
-function choiceCannotCommit(prog, ip) {
-  return prog[TABLE_RUNTIME]?.nonCommittingChoiceSites?.has(ip) === true;
-}
-function failureRollbackClean(prog, ip) {
-  return prog[TABLE_RUNTIME]?.failureRollbackCleanSites?.has(ip) === true;
-}
-var WIDE_CLASS_PREFIX_LO = 65535;
-var WIDE_CLASS_PREFIX_HI = 0;
-function validateClassRange(lo, hi) {
-  for (const cp of [lo, hi]) {
-    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
-      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
-    }
-  }
-  if (lo > hi) {
-    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
-  }
-}
-function encodeClassSpec(ranges) {
-  let wide = false;
-  for (const range2 of ranges) {
-    validateClassRange(range2.lo, range2.hi);
-    if (range2.hi > 65535) wide = true;
+function encodeClassSpec(ranges) {
+  let wide = false;
+  for (const range2 of ranges) {
+    validateClassRange(range2.lo, range2.hi);
+    if (range2.hi > 65535) wide = true;
   }
   if (!wide) {
     let spec2 = "";
@@ -6416,6 +5915,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 = [];
@@ -6489,6 +5993,616 @@ function resolveTable(prog) {
   return built;
 }
 
+// src/analysis/gating.ts
+function childrenOf2(d) {
+  switch (d.tag) {
+    case "sequence":
+    case "choice":
+      return d.parsers;
+    case "dispatch":
+      return [
+        d.selector,
+        ...d.cases.map((c) => c.parser),
+        ...d.matchers ? d.matchers.map((c) => c.parser) : [],
+        ...d.otherwise === void 0 ? [] : [d.otherwise]
+      ];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "recover":
+      return [d.parser, d.sentinel];
+    case "scanTo":
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? [] : [d.recoverAt],
+        ...d.stopAt === void 0 ? [] : [d.stopAt]
+      ];
+    case "grammar":
+      return d.triviaParser ? [d.parser, d.triviaParser] : [d.parser];
+    case "routed":
+      return d.fallback ? [d.fallback] : [];
+    case "lines":
+      return [d.prefix, d.body, ...d.first === void 0 ? [] : [d.first], ...d.lazy === void 0 ? [] : [d.lazy]];
+    case "columns":
+      return [];
+    // A `lazy` is a REFERENCE, not a subtree. Descending through it would make
+    // every rule's walk cover the whole reachable grammar — site paths become
+    // nonsense, and a structural hash includes half the grammar. Treated as a
+    // leaf, keyed by the rule name it refers to, which is also the right
+    // semantics: two productions referencing `g.Ident` really do fill that slot
+    // the same way.
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "adjacency":
+    case "unknown":
+      return [];
+    default: {
+      const rec = d;
+      return rec.parser ? [rec.parser] : [];
+    }
+  }
+}
+var ch = (c) => c >= 32 && c < 127 ? `'${String.fromCharCode(c)}'` : `\\u${c}`;
+function firstSetToString(fs3) {
+  if (fs3.kind === "any") return "ANY";
+  if (fs3.kind === "empty") return "(empty)";
+  return fs3.ranges.map((r) => r.lo === r.hi ? ch(r.lo) : `${ch(r.lo)}-${ch(r.hi)}`).join(",");
+}
+
+// src/analysis/commitment.ts
+function mayFail(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return true;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+      return d.value.length > 0;
+    case "trivia":
+      return false;
+    // `optional`/`many`/a min-0 `sepBy` swallow an ORDINARY failure — zero
+    // repetitions is a match. They do NOT swallow a COMMITTED one: a dispatch
+    // that has selected an arm and then failed inside it breaks out past every
+    // enclosing repeat, straight to the fallible boundary. So these are total
+    // exactly when their body cannot commit. (Measured: treating them as
+    // unconditionally total left an extra zero-width leaf in
+    // `BareInterpolatedSelector` on benchmark.less — a rollback the legacy
+    // build fired and this one had deleted.)
+    case "optional":
+    case "many":
+      return mayCommitFailure(d.parser);
+    case "sepBy":
+      return d.min >= 1 ? mayFail(d.parser, seen) : mayCommitFailure(d.parser) || mayCommitFailure(d.separator);
+    case "oneOrMore":
+      return mayFail(d.parser, seen);
+    case "sequence":
+      return d.parsers.some((x) => mayFail(x, seen));
+    // Delegating wrappers: as fallible as what they wrap.
+    case "node":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "token":
+    case "leaf":
+      return mayFail(d.parser, seen);
+    case "lazy": {
+      try {
+        return mayFail(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    // An adjacency assertion is a TEST — failing is its whole job.
+    case "adjacency":
+      return true;
+    default:
+      return true;
+  }
+}
+function mayLeavePartialCapture(p, seen = /* @__PURE__ */ new Set(), triviaActive = true) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    // Atomic / non-capturing-then-failing: a failure happens before any push.
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    // Adjacency probes with `_cap = 0` / no `commit()`: it cannot push anything.
+    case "adjacency":
+    case "not":
+    // peek(): emitted under a non-capturing probe ctx and zero-width on both
+    // outcomes, so it can never leave a partial capture behind.
+    case "peek":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "scanTo":
+    case "unknown":
+    case "columns":
+      return false;
+    // A run's prefixes are probed detached; only its body can capture.
+    case "lines":
+      return mayLeavePartialCapture(d.body, seen, triviaActive);
+    // node() captures into its own private buffers and rolls them back on
+    // failure (emitNode restores _ctx.* and never pushes on the !ok path).
+    case "node":
+      return false;
+    // choice/firstMatch already roll back each failed arm; on overall failure
+    // nothing committed remains.
+    case "choice":
+      return false;
+    case "dispatch":
+      return capturesLeaf(d.selector, new Set(seen)) || d.cases.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) || (d.matchers ? d.matchers.some((x) => mayLeavePartialCapture(x.parser, new Set(seen), triviaActive) || capturesLeaf(x.parser, new Set(seen))) : false) || (d.otherwise ? mayLeavePartialCapture(d.otherwise, new Set(seen), triviaActive) || capturesLeaf(d.otherwise, new Set(seen)) : false);
+    case "attempt":
+      return false;
+    // optional never fails; many/oneOrMore only "fail" with zero captured items.
+    case "optional":
+    case "many":
+    case "oneOrMore":
+      return false;
+    // sepBy emits its own per-iteration rollback in emitSepBy.
+    case "sepBy":
+      return false;
+    // A sequence is the real case: an earlier capturing term followed by a term
+    // that can fail leaves the earlier captures buffered.
+    //
+    // BOTH halves of that sentence are load-bearing, and the second half is what
+    // this walk exists to exploit. "Some earlier term captures" alone was the old
+    // test, and it is true of very nearly every sequence in a real grammar — a
+    // sequence almost always opens with a literal or a node. The rollback is only
+    // reachable if something AFTER the capture can still fail; once the remainder
+    // is total (`optional`/`many`/trivia/a min-0 `sepBy`), the sequence has no
+    // failure path left to roll back from, and the save+restore is dead code.
+    //
+    // `captured` tracks whether anything is in the buffers yet as the scan moves
+    // left to right. Two things put it there:
+    //   - a term that captures (`capturesLeaf`/`hasNodeDef`), and
+    //   - the inter-term TRIVIA scan, which under `capturing` pushes into
+    //     `_cstRawChildren`/`_cstTriviaLog` BEFORE the term at each boundary
+    //     i >= 1. `emitSeqValues` only rewinds that push on the term's SUCCESS
+    //     path (the "matched empty, so leave the whitespace out of the span"
+    //     branch); a term that FAILS breaks straight out with the trivia still
+    //     buffered, so from boundary 1 onward the buffers are dirty regardless of
+    //     what the earlier terms did.
+    // Each term is also asked about itself: a nested sequence can leave its own
+    // partial capture behind, and its terms are emitted inline into this same
+    // block with no boundary of their own to roll them back.
+    case "sequence": {
+      const parts = d.parsers;
+      let captured = false;
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (i > 0 && triviaActive) captured = true;
+        if (captured && mayFail(part)) return true;
+        if (mayLeavePartialCapture(part, seen, triviaActive)) return true;
+        if (capturesLeaf(part) || hasNodeDef(part)) captured = true;
+      }
+      return false;
+    }
+    // Delegating wrappers: defer to the wrapped parser.
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "recover":
+      return mayLeavePartialCapture(d.parser, seen, triviaActive);
+    case "lazy": {
+      try {
+        return mayLeavePartialCapture(d.thunk(), seen, triviaActive);
+      } catch {
+        return true;
+      }
+    }
+    // Unknown shapes: be safe and keep the rollback.
+    default:
+      return true;
+  }
+}
+function capturesLeaf(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "node":
+    case "token":
+    case "routed":
+    case "leaf":
+      return true;
+    case "not":
+    case "peek":
+    case "guard":
+    case "adjacency":
+    case "trivia":
+    case "unknown":
+      return false;
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => capturesLeaf(x, seen));
+    case "dispatch":
+      return capturesLeaf(d.selector, seen) || d.cases.some((x) => capturesLeaf(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => capturesLeaf(entry.parser, seen)) : false) || (d.otherwise ? capturesLeaf(d.otherwise, seen) : false);
+    case "sepBy":
+      return capturesLeaf(d.parser, seen) || capturesLeaf(d.separator, seen);
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "label":
+    case "field":
+    case "expect":
+    case "withCtx":
+    case "grammar":
+    case "recover":
+      return capturesLeaf(d.parser, seen);
+    case "scanTo":
+      return true;
+    case "lines":
+      return capturesLeaf(d.body, seen);
+    case "columns":
+      return true;
+    case "lazy": {
+      try {
+        return capturesLeaf(d.thunk(), seen);
+      } catch {
+        return true;
+      }
+    }
+    default:
+      return true;
+  }
+}
+function hasNodeDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return true;
+    case "lazy": {
+      try {
+        return hasNodeDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "not":
+    case "peek":
+    case "transform":
+      return hasNodeDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasNodeDef(x, seen));
+    case "dispatch":
+      return hasNodeDef(d.selector, seen) || d.cases.some((x) => hasNodeDef(x.parser, seen)) || (d.matchers ? d.matchers.some((entry) => hasNodeDef(entry.parser, seen)) : false) || (d.otherwise ? hasNodeDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.separator, seen);
+    case "scanTo":
+      return hasNodeDef(d.sentinel, seen) || d.skip.some((x) => hasNodeDef(x, seen)) || d.recoverAt !== void 0 && hasNodeDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasNodeDef(d.stopAt, seen);
+    case "lines":
+      return hasNodeDef(d.body, seen);
+    case "recover":
+      return hasNodeDef(d.parser, seen) || hasNodeDef(d.sentinel, seen);
+    case "expect":
+      return hasNodeDef(d.parser, seen);
+    case "withCtx":
+      return hasNodeDef(d.parser, seen);
+    default:
+      return false;
+  }
+}
+function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return false;
+  seen.add(p);
+  const d = p._def;
+  switch (d.tag) {
+    case "node":
+      return d.build !== void 0 || hasDirectBuildDef(d.parser, seen);
+    case "lazy": {
+      try {
+        return hasDirectBuildDef(d.thunk(), seen);
+      } catch {
+        return false;
+      }
+    }
+    case "grammar":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "optional":
+    case "many":
+    case "oneOrMore":
+    case "attempt":
+    case "not":
+    case "peek":
+    case "withCtx":
+    case "expect":
+    case "transform":
+      return hasDirectBuildDef(d.parser, seen);
+    case "sequence":
+    case "choice":
+      return d.parsers.some((x) => hasDirectBuildDef(x, seen));
+    case "dispatch":
+      return hasDirectBuildDef(d.selector, seen) || d.cases.some((x) => hasDirectBuildDef(x.parser, seen)) || (d.matchers ? d.matchers.some((x) => hasDirectBuildDef(x.parser, seen)) : false) || (d.otherwise ? hasDirectBuildDef(d.otherwise, seen) : false);
+    case "sepBy":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.separator, seen);
+    case "scanTo":
+      return hasDirectBuildDef(d.sentinel, seen) || d.skip.some((x) => hasDirectBuildDef(x, seen)) || d.recoverAt !== void 0 && hasDirectBuildDef(d.recoverAt, seen) || d.stopAt !== void 0 && hasDirectBuildDef(d.stopAt, seen);
+    case "lines":
+      return hasDirectBuildDef(d.body, seen);
+    case "recover":
+      return hasDirectBuildDef(d.parser, seen) || hasDirectBuildDef(d.sentinel, seen);
+    case "routed":
+      return d.fallback ? hasDirectBuildDef(d.fallback, seen) : false;
+    default:
+      return false;
+  }
+}
+function mayCommitFailure(p, resolve3, memo = /* @__PURE__ */ new Map()) {
+  return reachesMarked(p, (node2) => commitFailureSuccessors(node2, resolve3), memo);
+}
+var NO_EDGES = [];
+function commitFailureSuccessors(p, resolve3) {
+  const d = p._def;
+  switch (d.tag) {
+    case "dispatch":
+    case "unknown":
+      return true;
+    case "choice":
+    case "sequence":
+      return d.parsers;
+    // A contained transaction reports every failure uncommitted.
+    case "attempt":
+      return d.contain === true ? NO_EDGES : [d.parser];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "transform":
+    case "label":
+    case "field":
+    case "grammar":
+    case "node":
+    case "token":
+    case "leaf":
+    case "withCtx":
+      return [d.parser];
+    case "sepBy":
+      return [d.parser, d.separator];
+    case "scanTo":
+      return [
+        d.sentinel,
+        ...d.skip,
+        ...d.recoverAt === void 0 ? NO_EDGES : [d.recoverAt],
+        ...d.stopAt === void 0 ? NO_EDGES : [d.stopAt]
+      ];
+    // A run's prefixes are probed detached; a committed failure reaches it only from its body.
+    case "lines":
+      return [d.body];
+    case "lazy": {
+      try {
+        return [d.thunk()];
+      } catch {
+        const name = p._ruleName;
+        const target = name === void 0 ? void 0 : resolve3?.(name);
+        return target === void 0 ? true : [target];
+      }
+    }
+    default:
+      return NO_EDGES;
+  }
+}
+function reachesMarked(root, successors, memo) {
+  const known = memo.get(root);
+  if (known !== void 0) return known;
+  const order = /* @__PURE__ */ new Map();
+  const low = [];
+  const found = [];
+  const stack = [];
+  const visit = (node2) => {
+    const at = low.length;
+    order.set(node2, at);
+    low.push(at);
+    found.push(false);
+    stack.push(node2);
+    const next = successors(node2);
+    if (next === true) found[at] = true;
+    else {
+      for (const child of next) {
+        if (found[at]) break;
+        const hit = memo.get(child);
+        if (hit !== void 0) {
+          if (hit) found[at] = true;
+          continue;
+        }
+        const seen = order.get(child);
+        if (seen !== void 0) {
+          if (seen < low[at]) low[at] = seen;
+          continue;
+        }
+        const k = visit(child);
+        if (low[k] < low[at]) low[at] = low[k];
+        if (found[k]) found[at] = true;
+      }
+    }
+    if (low[at] === at) {
+      const answer = found[at];
+      let member;
+      do {
+        member = stack.pop();
+        memo.set(member, answer);
+      } while (member !== node2);
+    }
+    return at;
+  };
+  return found[visit(root)];
+}
+function hasSemanticReduction(roots, externalRefs) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (parser2) => {
+    if (seen.has(parser2)) return false;
+    seen.add(parser2);
+    const def = parser2._def;
+    if (def.tag === "transform" && !def.recognitionOnly) return true;
+    if (def.tag === "choice" && def.gates.some(Boolean)) return true;
+    if (def.tag === "guard" || def.tag === "withCtx") return true;
+    if (def.tag === "node" && def.build !== void 0) return true;
+    if (def.tag === "lazy") {
+      if (externalRefs?.has(parser2)) return false;
+      try {
+        return visit(def.thunk());
+      } catch {
+        return true;
+      }
+    }
+    return childrenOf2(def).some(visit);
+  };
+  return roots.some(visit);
+}
+function classifyRuleMap(ruleMap) {
+  const externalRefs = /* @__PURE__ */ new Set();
+  const scanned = /* @__PURE__ */ new Set();
+  const scanExternal = (p) => {
+    if (scanned.has(p)) return;
+    scanned.add(p);
+    const def = p._def;
+    if (def.tag === "lazy") {
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        resolved = void 0;
+      }
+      if (resolved === void 0) {
+        if (p._ruleName) externalRefs.add(p);
+        return;
+      }
+      scanExternal(resolved);
+      return;
+    }
+    for (const child of childrenOf2(def)) scanExternal(child);
+  };
+  for (const [, rule] of ruleMap) scanExternal(rule);
+  return {
+    hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
+    isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs)
+  };
+}
+
+// src/table/ops.ts
+var OP_LIT = 1;
+var OP_RX = 2;
+var OP_SEQ = 3;
+var OP_SEQV = 4;
+var OP_CHOICE = 5;
+var OP_REP = 6;
+var OP_REPV = 7;
+var OP_OPT = 8;
+var OP_XFORM = 9;
+var OP_NODE = 10;
+var OP_RULE = 11;
+var OP_GATE = 12;
+var OP_NOT = 13;
+var OP_PEEK = 14;
+var OP_LEAF = 15;
+var OP_EMPTY = 16;
+var OP_LIT_TRACK = 17;
+var OP_RX_TRACK = 18;
+var OP_NODE_TRACK = 19;
+var OP_SCOPE = 20;
+var OP_EXPECT = 21;
+var OP_SEQX = 22;
+var OP_SCAN = 23;
+var OP_FIELD = 24;
+var OP_LIT_CI = 27;
+var OP_LIT_CI_TRACK = 28;
+var OP_TOKEN = 29;
+var OP_SCOPE_CAP = 30;
+var OP_WITHCTX = 31;
+var OP_GUARD = 32;
+var OP_ADJ = 33;
+var OP_GREEDY = 34;
+var OP_REJECT = 35;
+var OP_ARMGATE = 36;
+var OP_LIVE = 37;
+var OP_ATTEMPT = 38;
+var OP_LABEL = 39;
+var OP_COV = 40;
+var OP_SCOPE_PLAIN = 41;
+var OP_LEX_BODY = 42;
+var OP_LEX_PROGRAM = 43;
+var OP_SOURCE_LEAF = 44;
+var OP_DISPATCH = 25;
+var OP_ROUTED = 26;
+var OP_NAMES = {
+  [OP_LIT]: "LIT",
+  [OP_RX]: "RX",
+  [OP_SEQ]: "SEQ",
+  [OP_SEQV]: "SEQV",
+  [OP_CHOICE]: "CHOICE",
+  [OP_REP]: "REP",
+  [OP_REPV]: "REPV",
+  [OP_OPT]: "OPT",
+  [OP_XFORM]: "XFORM",
+  [OP_NODE]: "NODE",
+  [OP_RULE]: "RULE",
+  [OP_GATE]: "GATE",
+  [OP_NOT]: "NOT",
+  [OP_PEEK]: "PEEK",
+  [OP_LEAF]: "LEAF",
+  [OP_SOURCE_LEAF]: "SOURCE_LEAF",
+  [OP_EMPTY]: "EMPTY",
+  [OP_LIT_TRACK]: "LIT_TRACK",
+  [OP_RX_TRACK]: "RX_TRACK",
+  [OP_NODE_TRACK]: "NODE_TRACK",
+  [OP_SCOPE]: "SCOPE",
+  [OP_EXPECT]: "EXPECT",
+  [OP_SEQX]: "SEQX",
+  [OP_SCAN]: "SCAN",
+  [OP_FIELD]: "FIELD",
+  [OP_LIT_CI]: "LIT_CI",
+  [OP_LIT_CI_TRACK]: "LIT_CI_TRACK",
+  [OP_DISPATCH]: "DISPATCH",
+  [OP_ROUTED]: "ROUTED",
+  [OP_TOKEN]: "TOKEN",
+  [OP_SCOPE_CAP]: "SCOPE_CAP",
+  [OP_WITHCTX]: "WITHCTX",
+  [OP_GUARD]: "GUARD",
+  [OP_ADJ]: "ADJ",
+  [OP_GREEDY]: "GREEDY",
+  [OP_REJECT]: "REJECT",
+  [OP_ARMGATE]: "ARMGATE",
+  [OP_LIVE]: "LIVE",
+  [OP_ATTEMPT]: "ATTEMPT",
+  [OP_LABEL]: "LABEL",
+  [OP_COV]: "COV",
+  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN",
+  [OP_LEX_BODY]: "LEX_BODY",
+  [OP_LEX_PROGRAM]: "LEX_PROGRAM"
+};
+
 // src/compiler/direct-projection.ts
 function directArrayProjection(fn, fnSrc, arity) {
   let source = fnSrc;
@@ -7369,6 +7483,7 @@ var Encoder = class {
       case "expect":
       case "recover":
       case "scanTo":
+      case "lines":
       case "unknown":
         return true;
       case "lazy": {
@@ -7385,6 +7500,33 @@ var Encoder = class {
         return childrenOf2(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(fs3) {
     if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return -1;
@@ -7396,12 +7538,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(fs3) {
-    if (fs3.kind !== "ranges" || fs3.ranges.length === 0) return -1;
-    const hit = this.ccIndex.get(encodeClassSpec(fs3.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`).
@@ -7589,6 +7738,18 @@ var Encoder = class {
       open: bal.open,
       close: bal.close
     }));
+    if (d.tag === "lines") {
+      return this.emit(OP_SCAN, this.scanSlot({
+        kind: 2,
+        flags: 0,
+        skip: [],
+        prefix: this.subtree(d.prefix),
+        body: this.subtree(d.body),
+        ...d.first === void 0 ? {} : { first: this.subtree(d.first) },
+        ...d.lazy === void 0 ? {} : { lazy: this.subtree(d.lazy) }
+      }));
+    }
+    if (d.tag === "columns") return this.emit(OP_SCAN, this.scanSlot({ kind: 3, flags: 0, skip: [], n: d.n }));
     if (d.tag === "scanTo") {
       const sentDef = d.sentinel._def;
       return this.emit(OP_SCAN, this.scanSlot({
@@ -7694,6 +7855,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 gate2 = d.gates[order[k]];
+            if (gate2 !== null && gate2 !== void 0) classes[k] = -1;
+          }
+        }
         const dispIdx = this.disp.length;
         this.disp.push(classes);
         let rollbackMask = kids.length > 31 ? -1 : 0;
@@ -7723,7 +7890,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);
@@ -7747,7 +7914,7 @@ var Encoder = class {
         return d.min >= 2 ? this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, flags, this.expected(deriveExpected(d.parser))) : this.emit(OP_REP, child, d.min, d.max ?? -1, sep2, flags);
       }
       case "optional": {
-        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;
       }
@@ -7795,8 +7962,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 fs3 = 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 fs3 = this.gateFirstSet(d.parser);
         if (fs3.kind === "any") return body;
         const cls = this.charClass(fs3);
         if (cls < 0) return body;
@@ -7888,7 +8055,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":
@@ -7909,14 +8076,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 fs3 = d.parser._def.tag === "lazy" ? firstSetOf(d.parser, /* @__PURE__ */ new Set(), this.refResolver(), this.activeTrivia) : d.parser._meta.firstSet;
-        if (fs3.kind === "any" || matchesEmpty(d.parser)) return inner;
+        const fs3 = this.gateFirstSet(d.parser);
+        if (fs3.kind === "any" || matchesEmpty(d.parser, /* @__PURE__ */ new Set(), this.refResolver())) return inner;
         const cls = this.charClass(fs3);
         if (cls < 0) return inner;
         const e = deriveExpected(d.parser);
@@ -8035,12 +8202,7 @@ var Encoder = class {
     };
     const seen = /* @__PURE__ */ new Set();
     const refs = [];
-    for (const s of this.scans) {
-      if (s.sentinel !== void 0) refs.push(s.sentinel);
-      if (s.recoverAt !== void 0) refs.push(s.recoverAt);
-      if (s.stopAt !== void 0) refs.push(s.stopAt);
-      refs.push(...s.skip);
-    }
+    for (const s of this.scans) refs.push(...scanRefs(s));
     for (const set of this.scanSkipSets) refs.push(...set);
     const stack = [...Object.values(this.rules), ...refs.map((r) => r[0])];
     while (stack.length > 0) {
@@ -8060,7 +8222,11 @@ var Encoder = class {
       skip: s.skip.map(res),
       ...s.sentinel === void 0 ? {} : { sentinel: res(s.sentinel) },
       ...s.recoverAt === void 0 ? {} : { recoverAt: res(s.recoverAt) },
-      ...s.stopAt === void 0 ? {} : { stopAt: res(s.stopAt) }
+      ...s.stopAt === void 0 ? {} : { stopAt: res(s.stopAt) },
+      ...s.prefix === void 0 ? {} : { prefix: res(s.prefix) },
+      ...s.body === void 0 ? {} : { body: res(s.body) },
+      ...s.first === void 0 ? {} : { first: res(s.first) },
+      ...s.lazy === void 0 ? {} : { lazy: res(s.lazy) }
     }));
     this.scanSkipSets = this.scanSkipSets.map((set) => set.map(res));
   }
@@ -8902,7 +9068,7 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
   if (shape.kind === "alt") {
     const okV = mint("_ok");
     const endV2 = mint("_end");
-    const lines = [`${ind}let ${okV} = false`, `${ind}let ${endV2} = ${start}`];
+    const lines2 = [`${ind}let ${okV} = false`, `${ind}let ${endV2} = ${start}`];
     if (shape.arms.length >= 2 && shape.arms.every((a) => a.kind === "litFold" && a.open.length >= 1)) {
       const groups = /* @__PURE__ */ new Map();
       for (const a of shape.arms) {
@@ -8911,60 +9077,60 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
         const lower = f >= 65 && f <= 90 ? f + 32 : f;
         (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
       }
-      lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
       for (const [lower, arms] of groups) {
         const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
-        lines.push(`${ind}  ${labels} {`);
+        lines2.push(`${ind}  ${labels} {`);
         for (const open of arms) {
           const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
           const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
-          lines.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+          lines2.push(`${ind}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
         }
-        lines.push(`${ind}    break`);
-        lines.push(`${ind}  }`);
+        lines2.push(`${ind}    break`);
+        lines2.push(`${ind}  }`);
       }
-      lines.push(`${ind}}`);
-      return { setup: lines, ok: okV, end: endV2 };
+      lines2.push(`${ind}}`);
+      return { setup: lines2, ok: okV, end: endV2 };
     }
     if (shape.disjoint) {
       const plan = planAltSwitch(shape.firsts);
       if (plan.kind === "switch") {
-        lines.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        lines2.push(`${ind}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
         shape.arms.forEach((arm, k) => {
           const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
           const m = emitShapeMatch(arm, start, mint, `${ind}    `, firstChar);
-          lines.push(`${ind}  ${labels} {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}    ${okV} = ${m.ok}`);
-          lines.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}    break`);
-          lines.push(`${ind}  }`);
+          lines2.push(`${ind}  ${labels} {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}    ${okV} = ${m.ok}`);
+          lines2.push(`${ind}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}    break`);
+          lines2.push(`${ind}  }`);
         });
-        lines.push(`${ind}}`);
+        lines2.push(`${ind}}`);
       } else {
         const c0 = codeAt(start, firstChar);
         shape.arms.forEach((arm, k) => {
           const fs3 = shape.firsts[k];
           const cond = fs3.negated ? `!(${classCond(c0, fs3.ranges)})` : `(${classCond(c0, fs3.ranges)})`;
           const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-          lines.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-          lines.push(...m.setup);
-          lines.push(`${ind}  ${okV} = ${m.ok}`);
-          lines.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
-          lines.push(`${ind}}`);
+          lines2.push(`${ind}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines2.push(...m.setup);
+          lines2.push(`${ind}  ${okV} = ${m.ok}`);
+          lines2.push(`${ind}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines2.push(`${ind}}`);
         });
       }
     } else {
       const lbl = mint("_alt");
-      lines.push(`${ind}${lbl}: {`);
+      lines2.push(`${ind}${lbl}: {`);
       for (const arm of shape.arms) {
         const m = emitShapeMatch(arm, start, mint, `${ind}  `, firstChar);
-        lines.push(...m.setup);
-        lines.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
+        lines2.push(...m.setup);
+        lines2.push(`${ind}  if (${m.ok}) { ${okV} = true; ${endV2} = ${m.end}; break ${lbl} }`);
       }
-      lines.push(`${ind}}`);
+      lines2.push(`${ind}}`);
     }
-    return { setup: lines, ok: okV, end: endV2 };
+    return { setup: lines2, ok: okV, end: endV2 };
   }
   if (shape.kind === "chars") {
     const cur = mint("_e");
@@ -8999,64 +9165,64 @@ function emitShapeMatch(shape, start, mint, ind, firstChar) {
       const c = classCond(`input.charCodeAt(${at})`, p.ranges);
       return p.negated ? `!(${c})` : `(${c})`;
     };
-    const lines = [`${ind}let ${endV2} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`];
+    const lines2 = [`${ind}let ${endV2} = ${start}`, `${ind}let ${okV} = false`, `${ind}do {`];
     let first = true;
     for (const p of shape.parts) {
       if (p.part === "lit") {
         const L = p.cps.length;
         const cond = litCond(endV2, p.cps, first ? firstChar : void 0);
         if (p.optional) {
-          lines.push(`${ind}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
+          lines2.push(`${ind}  if (${endV2} + ${L} <= input.length && (${cond})) ${endV2} += ${L}`);
         } else {
-          lines.push(`${ind}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
-          lines.push(`${ind}  ${endV2} += ${L}`);
+          lines2.push(`${ind}  if (!(${endV2} + ${L} <= input.length && (${cond}))) break`);
+          lines2.push(`${ind}  ${endV2} += ${L}`);
         }
       } else if (p.part === "run" && p.max === Infinity) {
         const s = mint("_s");
-        lines.push(`${ind}  const ${s} = ${endV2}`);
-        lines.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min === 1) lines.push(`${ind}  if (${endV2} === ${s}) break`);
-        else if (p.min > 1) lines.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min === 1) lines2.push(`${ind}  if (${endV2} === ${s}) break`);
+        else if (p.min > 1) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
       } else if (p.part === "run" && p.max === 1) {
         if (p.min === 1) {
-          lines.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
-          lines.push(`${ind}  ${endV2}++`);
+          lines2.push(`${ind}  if (!(${endV2} < input.length && ${runCond(p, endV2)})) break`);
+          lines2.push(`${ind}  ${endV2}++`);
         } else {
-          lines.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+          lines2.push(`${ind}  if (${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
         }
       } else if (p.part === "run") {
         const s = mint("_s");
-        lines.push(`${ind}  const ${s} = ${endV2}`);
-        lines.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
-        if (p.min > 0) lines.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
+        lines2.push(`${ind}  const ${s} = ${endV2}`);
+        lines2.push(`${ind}  while (${endV2} - ${s} < ${p.max} && ${endV2} < input.length && ${runCond(p, endV2)}) ${endV2}++`);
+        if (p.min > 0) lines2.push(`${ind}  if (${endV2} - ${s} < ${p.min}) break`);
       } else {
         const inner = emitShapeMatch(p.inner, endV2, mint, `${ind}  `, first ? firstChar : void 0);
         if (!p.unbounded) {
-          lines.push(...inner.setup);
+          lines2.push(...inner.setup);
           if (p.min === 1) {
-            lines.push(`${ind}  if (!(${inner.ok})) break`);
-            lines.push(`${ind}  ${endV2} = ${inner.end}`);
+            lines2.push(`${ind}  if (!(${inner.ok})) break`);
+            lines2.push(`${ind}  ${endV2} = ${inner.end}`);
           } else {
-            lines.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
+            lines2.push(`${ind}  if (${inner.ok}) ${endV2} = ${inner.end}`);
           }
         } else {
           const progV = mint("_prog");
-          lines.push(`${ind}  let ${progV} = false`);
-          lines.push(`${ind}  while (true) {`);
-          lines.push(...inner.setup);
-          lines.push(`${ind}    if (!(${inner.ok})) break`);
-          lines.push(`${ind}    ${endV2} = ${inner.end}`);
-          lines.push(`${ind}    ${progV} = true`);
-          lines.push(`${ind}  }`);
-          if (p.min === 1) lines.push(`${ind}  if (!${progV}) break`);
+          lines2.push(`${ind}  let ${progV} = false`);
+          lines2.push(`${ind}  while (true) {`);
+          lines2.push(...inner.setup);
+          lines2.push(`${ind}    if (!(${inner.ok})) break`);
+          lines2.push(`${ind}    ${endV2} = ${inner.end}`);
+          lines2.push(`${ind}    ${progV} = true`);
+          lines2.push(`${ind}  }`);
+          if (p.min === 1) lines2.push(`${ind}  if (!${progV}) break`);
         }
       }
       first = false;
     }
-    lines.push(`${ind}  ${okV} = true`);
-    lines.push(`${ind}} while (false)`);
-    lines.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
-    return { setup: lines, ok: okV, end: endV2 };
+    lines2.push(`${ind}  ${okV} = true`);
+    lines2.push(`${ind}} while (false)`);
+    lines2.push(`${ind}if (!${okV}) ${endV2} = ${start}`);
+    return { setup: lines2, ok: okV, end: endV2 };
   }
   if (shape.kind === "litFold") {
     const openLen2 = shape.open.length;
@@ -9642,7 +9808,10 @@ 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"
 ];
 var RUNTIME_PRELUDE = `
 let _pfScan=null
@@ -9663,7 +9832,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}})}
@@ -9870,11 +10039,11 @@ function rebuildPools(cc, fx, disp, plan) {
     })
   };
 }
-function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
+function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false, select) {
   const { code, k, fx, disp, dsp, triviaLabelled } = t;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
   if (cfg.coverage) throw new Unemittable("a coverage assembly");
   const roots = [...Object.values(prog.rules), ...extraIps];
   const reachable = [...reachableSites(code, roots)];
@@ -9945,7 +10114,7 @@ function emitAssemblySource(t, prog, cfg, extraIps = [], staticBuild = false) {
     const op = code[ip];
     sinkBits.set(
       ip,
-      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC && (op === OP_REP || op === OP_REPV) ? 2 : 0)
+      op === OP_SCAN ? 3 : (op === OP_FIELD ? 1 : 0) | (op === OP_EXPECT || REC2 && (op === OP_REP || op === OP_REPV) ? 2 : 0)
     );
   }
   const sinkKids = [];
@@ -9969,6 +10138,8 @@ function emitAssemblySource(t, 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 = [];
@@ -10104,6 +10275,18 @@ return 1
     tokenDecisionRefs.set(dispatchIp, made);
     return made;
   }
+  function gateMissTest(gip) {
+    const resolved = t.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;
@@ -10114,8 +10297,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;
     }
@@ -10160,9 +10343,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) {
@@ -10302,14 +10493,28 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
         return `${head}EC.e=pos;return ''}`;
       case OP_GATE: {
         const child = link(code[ip + 2]);
-        const resolved = t.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}
+if(${gateMissTest(ip)}){ctx._fe=pos;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: {
@@ -10367,7 +10572,7 @@ if(v!==FAIL)return v
 const err={_tag:'parseError',span:${prog.lines === 1 ? "spanLines(ctx,pos,pos)" : "{start:pos,end:pos}"},expected:${xf}}
 const es=ctx._errors
 if(es!==undefined)es.push(err)
-${REC ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
+${REC2 ? "if(ctx._tolerant===true)captureError(ctx,err)\n" : ""}ctx._fc=false
 EC.e=pos
 return err
 }`;
@@ -10488,7 +10693,7 @@ return v
       }
       case OP_LEX_PROGRAM: {
         const programId = code[ip + 1];
-        const run = hoist("lexProgram", `LEXPROG[${programId}]`);
+        const run2 = hoist("lexProgram", `LEXPROG[${programId}]`);
         const scanId = t.lexPrograms[programId].scan;
         if (scanId !== void 0) return `${head}
 const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan
@@ -10506,7 +10711,7 @@ ctx._cstTriviaLog=undefined
 ctx._triviaLog=undefined
 ctx._rootTriviaLog=undefined
 let e
-try{e=${run}(input,pos,ctx,SCANS[${scanId}])}finally{
+try{e=${run2}(input,pos,ctx,SCANS[${scanId}])}finally{
 _pfScan=sScan
 ctx.trivia=sTri
 ctx.triviaKindLabels=sKinds
@@ -10525,7 +10730,7 @@ EC.e=e
 return v
 }`;
         return `${head}
-const e=${run}(input,pos,ctx)
+const e=${run2}(input,pos,ctx)
 if(e<0)return FAIL
 const v=input.slice(pos,e)
 if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)pushCstLeaf(ctx,{_tag:'leaf',value:v,span:{start:pos,end:e}})
@@ -10536,7 +10741,7 @@ return v
       /* ── transaction ─────────────────────────────────────────────────────── */
       case OP_ATTEMPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && failureRollbackClean(prog, ip);
         const p = tmp();
         return `${head}
 ${clean ? "" : emitMark(p, L.buf, L.raw, sinks)}
@@ -10565,7 +10770,7 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], "EC.e=pos;return null")}${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){EC.e=pos;return null}
@@ -10579,7 +10784,7 @@ return FAIL
         const xf = fxRef(code[ip + 2]);
         const p = tmp();
         return `${head}
-${emitMark(p, L.buf, L.raw, sinks)}
+${lookaheadMiss(code[ip + 1], `ctx._fe=pos;ctx._fx=${xf};return FAIL`)}${emitMark(p, L.buf, L.raw, sinks)}
 const v=${child}(input,pos,ctx)
 ${emitRollback(p, L.buf, L.raw, sinks)}
 if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
@@ -10589,10 +10794,10 @@ return null
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
-        const clean = !REC && failureRollbackClean(prog, ip);
+        const clean = !REC2 && 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){
@@ -10619,15 +10824,15 @@ return v
           const childIp = code[base + i];
           kids.push(code[childIp] === OP_ADJ ? "" : link(childIp));
         }
-        const sy = REC ? `${tmp()}sy` : "";
+        const sy = REC2 ? `${tmp()}sy` : "";
         const pub = (i) => {
           const s = sentRef(code[base + n + i]);
           return s === "undefined" ? `ctx._sync=${sy}` : `ctx._sync=${s}??${sy}`;
         };
         const parts = [head];
-        if (REC) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
+        if (REC2) parts.push(`const ${sy}=ctx._sync`, "try{", pub(0));
         parts.push(`const v0=${kids[0]}(input,pos,ctx)`, "if(v0===FAIL)return FAIL");
-        const close = () => REC ? `${parts.join("\n")}
+        const close = () => REC2 ? `${parts.join("\n")}
 }finally{ctx._sync=${sy}}
 }` : `${parts.join("\n")}
 }`;
@@ -10640,7 +10845,7 @@ return v
         for (let i = 1; i < n; i++) {
           const vn = `v${i}`;
           parts.push(`let ${vn}`);
-          if (REC) parts.push(pub(i));
+          if (REC2) parts.push(pub(i));
           const childIp = code[base + i];
           if (code[childIp] === OP_ADJ) {
             const negated = code[childIp + 1] === 1;
@@ -10673,7 +10878,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
@@ -10700,7 +10905,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) => {
@@ -10725,7 +10930,7 @@ return FAIL
           if (maskable) maskPlan.push(~di);
           const p = tmp();
           const encodedRollbackMask = choiceRollbackMask(prog, ip) ?? -1;
-          const rollbackMask = REC ? -1 : encodedRollbackMask;
+          const rollbackMask = REC2 ? -1 : encodedRollbackMask;
           const hasRollback = rollbackMask !== 0;
           const startFailureExact = arms.every((_arm, i) => {
             const terminal = leadingScalarTerminal(code, code[base + i], 0, false);
@@ -10742,7 +10947,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();
@@ -10754,13 +10959,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(${gate2}){
@@ -10768,7 +10973,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");
@@ -10881,7 +11086,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
 }
@@ -10973,14 +11178,14 @@ return [key,v]
         const collect = op === OP_REP;
         let itemCls;
         let itemAscii = false;
-        if (!REC) {
+        if (!REC2) {
           const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
           if (itemClassIndex >= 0) {
             const resolved = t.cc[itemClassIndex];
             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}))`;
@@ -11021,11 +11226,11 @@ ${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
 ${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
 }`;
         const my = `${p}my`;
-        const recFx = REC ? fxRef(code[ip + 6]) : "";
-        const sepSent = REC ? sentRef(code[ip + 7]) : "undefined";
+        const recFx = REC2 ? fxRef(code[ip + 6]) : "";
+        const sepSent = REC2 ? sentRef(code[ip + 7]) : "undefined";
         const recSent = sep2 === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
         const recGate = sep2 !== void 0 || min === 0 ? "" : `count>=${min}&&`;
-        const recBranch = !REC ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
+        const recBranch = !REC2 ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
 ${sep2 === void 0 ? `${rb}
 ` : ""}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
 ${collect ? "out.push(rr.error)\n" : ""}captureError(ctx,rr.error)
@@ -11036,7 +11241,7 @@ continue
 `;
         return `${head}
 const out=${collect ? "[]" : "undefined"}
-${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
+${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC2 ? `const ${my}=ctx._sync
 ` : ""}${itemCls === void 0 ? "" : `const ${p}gate=ctx._probe===undefined
 `}let cur=pos
 let count=0
@@ -11075,7 +11280,7 @@ ${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 `}ctx._fc=false
 const v=${child}(input,itemStart,ctx)
 if(v===FAIL){
-${REC ? `if(ctx._fc===true){
+${REC2 ? `if(ctx._fc===true){
 ${rb}
 return FAIL
 }
@@ -11206,7 +11411,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) {
@@ -11267,7 +11472,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}}
@@ -11280,21 +11485,51 @@ 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 externalDefs = select === void 0 ? "" : `let _xScan
+${externals.map((ip) => `let _xp${ip}
+function _px${ip}(input,pos,ctx){const o=_xScan(_pfScan);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++
@@ -11321,7 +11556,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -11329,10 +11564,193 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
 
+// src/combinators/lines.ts
+function lineIndexAt(view, offset) {
+  const lines2 = view.lines;
+  let lo = 0, hi = lines2.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (lines2[mid].offset <= offset) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+var lineAt = (view, offset) => view.lines[lineIndexAt(view, offset)];
+function sourceOffset(view, offset) {
+  const line = lineAt(view, offset);
+  return line === void 0 ? offset : line.source + (offset - line.offset);
+}
+function columnAt(input, pos, ctx) {
+  const view = ctx.lineView;
+  let start, column, split;
+  const line = view === void 0 ? void 0 : lineAt(view, pos);
+  if (line !== void 0 && pos >= line.offset) {
+    start = line.offset;
+    column = line.column;
+    split = line.split;
+  } else {
+    start = input.lastIndexOf("\n", pos - 1) + 1;
+    column = 0;
+    split = 0;
+  }
+  for (let i = start; i < pos; i++) {
+    if (input.charCodeAt(i) === 9) {
+      const width = 4 - (column - (i === start ? split : 0)) % 4 - (i === start ? split : 0);
+      column += width;
+    } else column++;
+    split = 0;
+  }
+  return { column, split: pos === start ? split : 0 };
+}
+function columns(n) {
+  if (!Number.isInteger(n) || n < 0) throw new TypeError(`columns(n) needs a non-negative integer, got ${n}`);
+  const expected = [`columns(${n})`];
+  const meta = {
+    firstSet: n === 0 ? any() : { kind: "ranges", ranges: [{ lo: 9, hi: 9 }, { lo: 32, hi: 32 }] },
+    canMatchNewline: false,
+    isTrivia: false
+  };
+  return {
+    _tag: "columns",
+    _meta: meta,
+    _def: { tag: "columns", n },
+    parse(input, pos, ctx) {
+      const c = ctx;
+      let { column, split } = columnAt(input, pos, c);
+      const goal = column + n;
+      let at = pos;
+      while (column < goal) {
+        const code = input.charCodeAt(at);
+        if (code === 32) {
+          column++;
+          split = 0;
+          at++;
+          continue;
+        }
+        if (code !== 9) return { ok: false, expected, span: { start: at, end: at } };
+        const width = 4 - (column - split) % 4 - split;
+        if (column + width > goal) {
+          c._columnsSplit = { at, split: split + (goal - column) };
+          return { ok: true, value: input.slice(pos, at), span: { start: pos, end: at } };
+        }
+        column += width;
+        split = 0;
+        at++;
+      }
+      return { ok: true, value: input.slice(pos, at), span: { start: pos, end: at } };
+    }
+  };
+}
+function lines(prefix, body, options = {}) {
+  const { first, lazy } = options;
+  const opening = first ?? prefix;
+  const meta = {
+    // An opening that matches empty starts a run at any character.
+    firstSet: matchesEmpty(opening) ? any() : opening._meta.firstSet,
+    canMatchNewline: true,
+    isTrivia: false
+  };
+  return {
+    _tag: "lines",
+    _meta: meta,
+    _def: { tag: "lines", prefix, body, ...first === void 0 ? {} : { first }, ...lazy === void 0 ? {} : { lazy } },
+    parse(input, pos, ctx) {
+      const c = ctx;
+      const probe = createDetachedParseContext(false, ctx.state);
+      probe.lineView = c.lineView;
+      const run2 = [];
+      const parts = [];
+      let offset = 0;
+      for (let start = pos; start < input.length || start === pos; ) {
+        let end2 = input.indexOf("\n", start);
+        if (end2 < 0) end2 = input.length;
+        probe._columnsSplit = void 0;
+        const head = (run2.length === 0 ? opening : prefix).parse(input, start, probe);
+        let content;
+        let joined;
+        if (head.ok && head.span.end <= end2) {
+          content = head.span.end;
+          joined = "prefix";
+        } else if (run2.length === 0) {
+          return { ok: false, expected: head.ok ? ["line prefix"] : head.expected, span: { start, end: start } };
+        } else if (lazy !== void 0 && lazy.parse(input, start, probe).ok) {
+          content = start;
+          joined = "lazy";
+        } else break;
+        const mark = probe._columnsSplit;
+        const here = columnAt(input, content, c);
+        const split = joined === "prefix" && mark !== void 0 && mark.at === content ? mark.split : here.split;
+        run2.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
+        const text = input.slice(content, end2);
+        const newline = end2 < input.length;
+        parts.push(newline ? `${text}
+` : text);
+        offset += text.length + (newline ? 1 : 0);
+        start = end2 + 1;
+        if (!newline) break;
+      }
+      const view = { lines: run2, parent: c.lineView };
+      const saved = c.lineView, starts = c._lineStarts, lineIndex = c._lineIndex, scanned = c._lineScannedTo, probing = c._probe;
+      const errors = c._errors?.length ?? 0;
+      let cursor = -1;
+      if (probing !== void 0) for (const line2 of run2) {
+        if (probing.offset >= line2.source && probing.offset <= line2.end) {
+          cursor = line2.offset + probing.offset - line2.source;
+          break;
+        }
+      }
+      const inner = cursor < 0 ? void 0 : { offset: cursor, best: null };
+      c.lineView = view;
+      c._lineStarts = void 0;
+      c._lineIndex = void 0;
+      c._lineScannedTo = void 0;
+      c._probe = inner;
+      let result;
+      try {
+        result = body.parse(parts.join(""), 0, ctx);
+      } finally {
+        c.lineView = saved;
+        c._lineStarts = starts;
+        c._lineIndex = lineIndex;
+        c._lineScannedTo = scanned;
+        c._probe = probing;
+      }
+      if (inner?.best) failAt(c, inner.best.expected, sourceOffset(view, inner.best.span.start));
+      if (c._errors !== void 0) for (let i = errors; i < c._errors.length; i++) {
+        const error = c._errors[i];
+        error.span = { start: sourceOffset(view, error.span.start), end: sourceOffset(view, error.span.end) };
+      }
+      if (!result.ok) {
+        const at = sourceOffset(view, result.span.start);
+        return { ...result, span: { start: at, end: at } };
+      }
+      const stop = result.span.end;
+      const index = lineIndexAt(view, stop);
+      const line = run2[index];
+      const end = stop === line.offset && index > 0 ? run2[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      recordLineRangeFromContext(c, input, pos, end);
+      return { ok: true, value: result.value, span: { start: pos, end } };
+    }
+  };
+}
+
+// src/table/line-scan.ts
+function rebuildLineScan(s, subtree) {
+  if (s.kind === 2) {
+    return lines(subtree(s.prefix), subtree(s.body), {
+      ...s.first === void 0 ? {} : { first: subtree(s.first) },
+      ...s.lazy === void 0 ? {} : { lazy: subtree(s.lazy) }
+    });
+  }
+  if (s.kind === 3) return columns(s.n);
+  return void 0;
+}
+
 // src/combinators/scanTo.ts
 function resolveScanSkip(explicitSkip, raw, ctx) {
   if (raw) return [];
@@ -11577,6 +11995,70 @@ function escapeClassChar(ch2) {
   return ch2.replace(/[\\\]^-]/g, "\\$&");
 }
 
+// src/table/trivia-gap.ts
+function skipDeferredTrivia(input, cur, ctx) {
+  const triviaP = ctx.trivia;
+  const plain = ctx.trackLines !== true && ctx.captureTrivia !== true;
+  const gap = ctx._gap;
+  if (plain && 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, plain);
+  if (end >= 0) {
+    remember(cur, end, ctx, input, triviaP);
+    return end;
+  }
+  const scan = scanTriviaCompact(input, cur, ctx);
+  if (typeof scan !== "number") return commitTriviaScan(scan);
+  if (plain) remember(cur, scan, ctx, input, triviaP);
+  return scan;
+}
+function clearRunEnd(input, cur, ctx, triviaP, plain) {
+  const rootKinds = ctx._rootTriviaKindIndex;
+  const spec = triviaP?._meta.labeledTriviaSpec;
+  if (!plain || 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 prime(spec, triviaP, rootKinds) {
+  const ranges = [];
+  let bounded = true;
+  for (const arm of spec.arms) {
+    if (rootKinds[arm.label] === void 0) continue;
+    const fs3 = arm.parser._meta.firstSet;
+    if (fs3.kind === "any") bounded = false;
+    else if (fs3.kind === "ranges") ranges.push(...fs3.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 true;
+}
+
 // src/table/run-support.ts
 function lineCol(ctx, offset) {
   const starts = ctx._lineStarts ?? [0];
@@ -11613,6 +12095,19 @@ function lead(input, pos) {
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
 var FUSED_HOST_ELIDED = /* @__PURE__ */ Symbol.for("parseman.fusedHostElided");
+function assertHostModeCompatible(mode, build, hostBranchElided = true) {
+  const isCstHost = build?._parsemanCstOutput === true;
+  if (mode === "ast" && isCstHost && hostBranchElided) {
+    throw new Error(
+      "parseman: this parser was compiled for host mode \"ast\" (the default), so its nodes build through their own `build` callbacks and no positioned-CST branch was emitted. It cannot be driven with a positioned-CST host (cstBuildHost / a language-service host). Compile a second artifact from the SAME grammar with `compile(grammar, { hostMode: 'cst' })` \u2014 or, under the macro, a second `rules({ hostMode: 'cst' }, factory)` call site \u2014 and drive that one instead."
+    );
+  }
+  if (mode === "cst" && !isCstHost) {
+    throw new Error(
+      'parseman: this parser was compiled for host mode "cst", so every node builds through a positioned-CST `ctx.build` host. Pass one (e.g. `{ build: cstBuildHost }`), or use an artifact compiled with the default `hostMode: "ast"` to get the grammar\'s own AST.'
+    );
+  }
+}
 
 // src/grammar-metadata.ts
 var GRAMMAR_COVERAGE_DEFINITIONS = /* @__PURE__ */ Symbol.for("parseman.grammarCoverageDefinitions");
@@ -11649,7 +12144,7 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
     ...prog.labels === void 0 ? {} : { triviaKindLabels: prog.labels },
     ...prog.classified === 1 ? { rootTriviaClassified: true } : {}
   };
-  const lines = prog.lines === 1;
+  const lines2 = prog.lines === 1;
   const mode = prog.hostMode ?? "ast";
   const elided = mode === "ast" && hasDirectBuilder(prog);
   const coverageDefinitions = prog.cov === void 0 ? void 0 : Object.freeze(covDefinitions(prog).map(Object.freeze));
@@ -11677,7 +12172,7 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
       ctx._fe = -1;
       ctx._fx = EMPTY_FX;
       ctx._fc = false;
-      if (lines && ctx._lineStarts === void 0) {
+      if (lines2 && ctx._lineStarts === void 0) {
         ctx._lineStarts = [0];
         ctx._lineScannedTo = 0;
       }
@@ -11685,10 +12180,10 @@ function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(pr
       if (end < 0) {
         const fe = ctx._fe;
         const at = fe === void 0 || fe < 0 ? pos : fe;
-        const fspan = lines ? spanLines(ctx, at, at) : { start: at, end: at };
+        const fspan = lines2 ? spanLines(ctx, at, at) : { start: at, end: at };
         return committed2(ctx) ? { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan, committed: true } : { ok: false, expected: ctx._fx ?? EMPTY_FX, span: fspan };
       }
-      return { ok: true, value: d.lastValue(), span: lines ? spanLines(ctx, pos, end) : { start: pos, end } };
+      return { ok: true, value: d.lastValue(), span: lines2 ? spanLines(ctx, pos, end) : { start: pos, end } };
     };
     const ownTrivia = triviaOfRule(prog.rules[name]);
     const meta = ownTrivia === void 0 ? baseMeta : { ...baseMeta, grammarTrivia: ownTrivia };
@@ -11758,7 +12253,7 @@ function assemble(t, prog, cfg) {
   const triviaScan = t.triviaScan;
   const swapLegal = !cfg.trackLines;
   const hostCst = cfg.hostCst;
-  const REC = prog.rec === 1 && cfg.tolerant;
+  const REC2 = prog.rec === 1 && cfg.tolerant;
   const sentinels = /* @__PURE__ */ new Map();
   function sentinelFor(cls) {
     if (cls < 0) return void 0;
@@ -11773,6 +12268,9 @@ function assemble(t, 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];
@@ -11782,20 +12280,23 @@ function assemble(t, prog, cfg) {
     }
     return recognize;
   }
-  const labelExtraIps = [];
-  for (const s of prog.scans ?? []) {
-    for (const r of s.skip) labelExtraIps.push(r[0]);
-    if (s.sentinel !== void 0) labelExtraIps.push(s.sentinel[0]);
-    if (s.recoverAt !== void 0) labelExtraIps.push(s.recoverAt[0]);
-    if (s.stopAt !== void 0) labelExtraIps.push(s.stopAt[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();
   function pushLeaf(ctx, value, s, e) {
@@ -12087,9 +12588,7 @@ function assemble(t, 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;
@@ -12259,7 +12758,7 @@ function assemble(t, 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;
@@ -12342,7 +12841,7 @@ function assemble(t, 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;
@@ -12421,6 +12920,13 @@ function assemble(t, 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 = hybridPiece(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) => {
@@ -12428,7 +12934,7 @@ function assemble(t, prog, cfg) {
     } };
     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 = (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]) : countedPiece(lower(ip), ip);
     inFlight.delete(ip);
     holder.set(piece);
     memo.set(ip, piece);
@@ -12769,7 +13275,7 @@ function assemble(t, prog, cfg) {
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
         const expectSpan = (ctx, pos) => prog.lines === 1 ? spanLines(ctx, pos, pos) : { start: pos, end: pos };
-        if (REC) {
+        if (REC2) {
           return (input, pos, ctx) => {
             const v = child(input, pos, ctx);
             if (v !== FAIL) return v;
@@ -12965,7 +13471,12 @@ function assemble(t, prog, cfg) {
         }
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate2 = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -12988,7 +13499,13 @@ function assemble(t, prog, cfg) {
       case OP_PEEK: {
         const child = link(code[ip + 1]);
         const xf = fx[code[ip + 2]];
+        const gate2 = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            ctx._fe = pos;
+            ctx._fx = xf;
+            return FAIL;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -13010,7 +13527,12 @@ function assemble(t, prog, cfg) {
       }
       case OP_OPT: {
         const child = link(code[ip + 1]);
+        const gate2 = lookaheadClass(code[ip + 1]);
         return (input, pos, ctx) => {
+          if (gate2 !== null && !classHas2(gate2, lead(input, pos))) {
+            EC.e = pos;
+            return null;
+          }
           const need = markCst(ctx);
           const mRaw = MRAW;
           const mTl = MTL;
@@ -13108,8 +13630,8 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_LEX_PROGRAM: {
-        const run = t.lexPrograms[code[ip + 1]];
-        const scanId = run.scan;
+        const run2 = t.lexPrograms[code[ip + 1]];
+        const scanId = run2.scan;
         if (scanId !== void 0) {
           return (input, pos, ctx) => {
             const sTrivia = ctx.trivia, sKinds = ctx.triviaKindLabels;
@@ -13130,7 +13652,7 @@ function assemble(t, prog, cfg) {
             ctx._rootTriviaLog = void 0;
             let end;
             try {
-              end = run(input, pos, ctx, scans[scanId]);
+              end = run2(input, pos, ctx, scans[scanId]);
             } finally {
               SCAN = sScan;
               ctx.trivia = sTrivia;
@@ -13151,7 +13673,7 @@ function assemble(t, prog, cfg) {
           };
         }
         return (input, pos, ctx) => {
-          const end = run(input, pos, ctx);
+          const end = run2(input, pos, ctx);
           if (end < 0) return FAIL;
           const value = input.slice(pos, end);
           if (cstCaptureActive(ctx)) pushCstLeaf(ctx, { _tag: "leaf", value, span: { start: pos, end } });
@@ -13253,7 +13775,7 @@ function assemble(t, prog, cfg) {
             return next === void 0 ? cur : next(input, cur, ctx, values, inherited);
           };
         };
-        if (REC) {
+        if (REC2) {
           const first2 = link(code[base]);
           const firstSync = sentinelFor(code[base + n]);
           const runnerAt = (i) => {
@@ -13722,7 +14244,7 @@ function assemble(t, prog, cfg) {
         if (n === 2 || n === 3) {
           const a0 = link(code[base]), a1 = link(code[base + 1]);
           const a2 = n === 3 ? link(code[base + 2]) : void 0;
-          const predecide = !REC && !cfg.probe && !cfg.coverage && !cfg.trackLines;
+          const predecide = !REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines;
           const p0ip = predecide ? leadingScalarTerminal(code, code[base], 2, true, true) : -1;
           const p1ip = predecide ? leadingScalarTerminal(code, code[base + 1], 2, true, true) : -1;
           const p2ip = predecide && n === 3 ? leadingScalarTerminal(code, code[base + 2], 2, true, true) : -1;
@@ -13817,6 +14339,11 @@ function assemble(t, 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);
@@ -13947,7 +14474,7 @@ function assemble(t, prog, cfg) {
           const masked = bindMasked(0, EMPTY_EXPECTED_PREFIX);
           const pBit = [];
           const pRec = [];
-          if (!REC && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
+          if (!REC2 && !cfg.probe && !cfg.coverage && !cfg.trackLines) {
             for (let i = 0; i < n; i++) {
               for (const terminal of largeChoiceLiteralPretest(code, k, code[base + i]) ?? []) {
                 pBit.push(1 << i);
@@ -14125,7 +14652,7 @@ function assemble(t, prog, cfg) {
         return (input, pos, ctx) => {
           if (!pred(ctx.state)) {
             ctx._fc = false;
-            ctx._fe = pos;
+            ctx._fe = -1;
             ctx._fx = xf;
             return FAIL;
           }
@@ -14183,10 +14710,10 @@ function assemble(t, prog, cfg) {
         const itemFx = reportItem ? fx[code[ip + 6]] : EMPTY_FX2;
         const collect = op === OP_REP;
         const itemClassIndex = sepIp < 0 ? code[ip + 7] : -1;
-        const itemClass = !REC && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
+        const itemClass = !REC2 && itemClassIndex >= 0 ? cc[itemClassIndex] : void 0;
         const itemMayStart = itemClass === void 0 ? void 0 : (input, pos) => classHas2(itemClass, lead(input, pos));
         const skipBeforeFirst = sepIp < 0 && min === 0;
-        if (REC) {
+        if (REC2) {
           const itemFx2 = fx[code[ip + 6]];
           const sepSent = sentinelFor(code[ip + 7]);
           return (input, pos, ctx) => {
@@ -14531,7 +15058,7 @@ function assemble(t, 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]);
@@ -14544,10 +15071,10 @@ function assemble(t, 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);
             }
@@ -14598,14 +15125,7 @@ function assemble(t, prog, cfg) {
   let emitRefusal;
   let emitReached;
   {
-    const extraIps = [];
-    for (const s of prog.scans ?? []) {
-      for (const r of s.skip) extraIps.push(r[0]);
-      if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
-      if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
-      if (s.stopAt !== void 0) extraIps.push(s.stopAt[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) {
@@ -14686,7 +15206,7 @@ function assemble(t, prog, cfg) {
         lead,
         asciiFoldKey,
         ROUTED_FX,
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -14698,9 +15218,11 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia
       );
       emitReached = new Set(pre.reached);
+      if (emitted.ext !== void 0) HYBRID = emitted;
     }
     try {
       if (emitted !== void 0) throw new ServedByBuild();
@@ -14770,7 +15292,7 @@ function assemble(t, prog, cfg) {
         // — a strict one emits no reader — and through the SAME `sentinelFor` memo
         // the closure pieces use, so both engines resync to the same combinator
         // object rather than to two separately constructed ones.
-        REC ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
+        REC2 ? prog.cc.map((_, i) => sentinelFor(i)) : EMPTY_SENTS,
         matchesAt,
         recoverScan,
         orSentinel,
@@ -14782,7 +15304,8 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia
       );
       emitReached = em.reached;
     } catch (e) {
@@ -14793,7 +15316,7 @@ function assemble(t, 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;
@@ -14801,6 +15324,11 @@ function assemble(t, prog, cfg) {
     return link(ip);
   }
   for (const s of prog.scans ?? []) {
+    const rebuilt = rebuildLineScan(s, subtreeComb);
+    if (rebuilt !== void 0) {
+      scansArr.push(rebuilt);
+      continue;
+    }
     const skip = s.skip.map((r) => subtreeComb(r));
     const raw = (s.flags & 1) !== 0;
     if (s.kind === 1) {
@@ -14818,6 +15346,37 @@ function assemble(t, 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 {
@@ -14853,6 +15412,26 @@ function assemble(t, 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);
+  };
+}
+function countSiteVisits(prog, parse2, fns = prog.fns) {
+  const counts = new Int32Array(prog.code.length);
+  const profiled = ownTableProgram({ ...prog, fns, asm: [] });
+  SITE_COUNTS = counts;
+  try {
+    parse2(tableRules(profiled));
+  } finally {
+    SITE_COUNTS = void 0;
+  }
+  return counts;
+}
 var AssemblyCache = class {
   t;
   prog;
@@ -15042,6 +15621,11 @@ function emitScanSpec(s) {
   if (s.sent !== void 0) parts.push(`sent:${s.sent === null ? "null" : jsString(s.sent)}`);
   if (s.open !== void 0) parts.push(`open:${jsString(s.open)}`);
   if (s.close !== void 0) parts.push(`close:${jsString(s.close)}`);
+  for (const key of ["prefix", "body", "first", "lazy"]) {
+    const r = s[key];
+    if (r !== void 0) parts.push(`${key}:${emitRef(r)}`);
+  }
+  if (s.n !== void 0) parts.push(`n:${s.n}`);
   return `{${parts.join(",")}}`;
 }
 function emitDispatchSpec(d) {
@@ -15061,14 +15645,7 @@ function defaultAssemblyCfgs(prog) {
 function emitAssemblies(prog, cfgs) {
   if (cfgs.length === 0) return ["a:[],"];
   const t = resolveTable(prog);
-  const extraIps = [];
-  for (const s of prog.scans ?? []) {
-    for (const r of s.skip) extraIps.push(r[0]);
-    if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
-    if (s.recoverAt !== void 0) extraIps.push(s.recoverAt[0]);
-    if (s.stopAt !== void 0) extraIps.push(s.stopAt[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) {
@@ -15077,7 +15654,7 @@ function emitAssemblies(prog, cfgs) {
     seen.add(key);
     let em;
     try {
-      em = emitAssemblySource(t, prog, cfg, extraIps, true);
+      em = emitAssemblySource(t, prog, cfg, extraIps, true, cfg.select);
     } catch (e) {
       if (e instanceof Unemittable) continue;
       throw e;
@@ -15219,6 +15796,8 @@ function children(def, winners) {
         ...def.recoverAt === void 0 ? [] : [def.recoverAt],
         ...def.stopAt === void 0 ? [] : [def.stopAt]
       ];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
     case "lazy": {
       let resolved;
       try {
@@ -15362,6 +15941,10 @@ function payloadKey(p, d) {
       return `expect\0${d.label ?? ""}\0${d.expected.join("
")}`;
     case "scanTo":
       return `scanTo\0${d.raw}\0${d.orEOF}\0${d.recoverAt !== void 0}\0${d.stopAt !== void 0}`;
+    case "lines":
+      return `lines\0${d.first !== void 0}\0${d.lazy !== void 0}`;
+    case "columns":
+      return `columns\0${d.n}`;
     case "guard":
       return `guard\0${fnKey(d.predSrc, d.predicate)}`;
     case "adjacency":
@@ -15482,6 +16065,8 @@ function segment(d, index) {
       if (d.recoverAt !== void 0 && index === d.skip.length + 1) return "scanTo.recoverAt";
       return "scanTo.stopAt";
     }
+    case "lines":
+      return ["lines.prefix", "lines.body", d.first === void 0 ? "lines.lazy" : "lines.first", "lines.lazy"][index] ?? "lines";
     default:
       return d.tag;
   }
@@ -15864,36 +16449,36 @@ function findRegexFragments(visited) {
       if (branches.length >= 2) runs.add(branches.join("|"));
       for (let i = 0; i < branches.length; i++) {
         for (let n = 2; n <= Math.min(MAX_RUN, branches.length - i); n++) {
-          const run = branches.slice(i, i + n).join("|");
-          if (run.length < 4) continue;
-          runs.add(run);
+          const run2 = branches.slice(i, i + n).join("|");
+          if (run2.length < 4) continue;
+          runs.add(run2);
         }
       }
     }
-    for (const run of runs) {
-      let e = byRun.get(run);
+    for (const run2 of runs) {
+      let e = byRun.get(run2);
       if (e === void 0) {
-        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run.split("|").length };
-        byRun.set(run, e);
+        e = { occ: [], nodes: /* @__PURE__ */ new Set(), branches: run2.split("|").length };
+        byRun.set(run2, e);
       }
       if (e.nodes.has(v.p)) continue;
       e.nodes.add(v.p);
       e.occ.push({ site: v.site, source: d.source });
     }
   }
-  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run, e]) => ({ run, e, savings: (e.occ.length - 1) * run.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
+  const candidates = [...byRun.entries()].filter(([, e]) => e.occ.length >= 2).map(([run2, e]) => ({ run: run2, e, savings: (e.occ.length - 1) * run2.length })).sort((a, b) => b.e.occ.length - a.e.occ.length || b.savings - a.savings || b.run.length - a.run.length);
   const kept = [];
   for (const c of candidates) {
     if (kept.some((k) => k.e.occ.length >= c.e.occ.length && `|${k.run}|`.includes(`|${c.run}|`))) continue;
     kept.push(c);
   }
-  return kept.map(({ run, e }) => ({
+  return kept.map(({ run: run2, e }) => ({
     kind: "regex-fragment",
-    id: `regex-fragment:${run}`,
-    fragment: run,
+    id: `regex-fragment:${run2}`,
+    fragment: run2,
     branches: e.branches,
     count: e.occ.length,
-    savings: (e.occ.length - 1) * run.length,
+    savings: (e.occ.length - 1) * run2.length,
     sources: e.occ.map((o) => `/${o.source}/`),
     sites: e.occ.map((o) => o.site),
     suggestion: `this ${e.branches}-branch alternation is re-spelled in ${e.occ.length} DISTINCT regex() terminals. Hoist it to one shared source string and interpolate it (\`new RegExp(\\\`\u2026\\\${OP}\u2026\\\`)\`) or lift the shared part into its own terminal \u2014 an edit to the operator set currently has to land in ${e.occ.length} places, and the analysis cannot tell you when one of them drifts.`
@@ -16524,60 +17109,60 @@ function findKeywordRegexes(visited) {
 var sitesLine = (sites) => sites.slice(0, 6).map(siteToString).join("\n      ") + (sites.length > 6 ? `
       \u2026 and ${sites.length - 6} more` : "");
 function formatDuplicationFindings(report) {
-  const lines = [];
+  const lines2 = [];
   for (const f of report.structureLoss) {
-    lines.push(`parseman BUG [structure-loss] @ ${siteToString(f.site)}: arm[${f.earlier}] flattens \`${f.nodeType}\` where arm[${f.later}] structures it, on ${firstSetToString(f.on)}`);
-    lines.push(`  flat: ${f.earlierShape}`);
-    lines.push(`  rich: ${f.laterShape}`);
-    lines.push(`  lost: ${f.lostNodeTypes.map((t) => `\`${t}\``).join(", ")}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman BUG [structure-loss] @ ${siteToString(f.site)}: arm[${f.earlier}] flattens \`${f.nodeType}\` where arm[${f.later}] structures it, on ${firstSetToString(f.on)}`);
+    lines2.push(`  flat: ${f.earlierShape}`);
+    lines2.push(`  rich: ${f.laterShape}`);
+    lines2.push(`  lost: ${f.lostNodeTypes.map((t) => `\`${t}\``).join(", ")}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.rewrites) {
-    lines.push(`parseman ${f.bug ? "BUG" : "rewrite"} [${f.rewrite}${f.sepByVerdict === void 0 ? "" : `/${f.sepByVerdict}`}] @ ${siteToString(f.site)}${f.astNeutral ? "" : " (candidate \u2014 verify AST identity)"}`);
-    lines.push(`  from: ${f.from}`);
-    lines.push(`    to: ${f.to}`);
-    lines.push(`   fix: ${f.suggestion}`);
-    if (f.perf !== "") lines.push(`  perf: ${f.perf}`);
+    lines2.push(`parseman ${f.bug ? "BUG" : "rewrite"} [${f.rewrite}${f.sepByVerdict === void 0 ? "" : `/${f.sepByVerdict}`}] @ ${siteToString(f.site)}${f.astNeutral ? "" : " (candidate \u2014 verify AST identity)"}`);
+    lines2.push(`  from: ${f.from}`);
+    lines2.push(`    to: ${f.to}`);
+    lines2.push(`   fix: ${f.suggestion}`);
+    if (f.perf !== "") lines2.push(`  perf: ${f.perf}`);
   }
   for (const f of report.divergentNodes) {
-    lines.push(`parseman divergent-node: \`${f.nodeType}\` is built by ${f.count} different productions sharing ${f.sharedTerms.length} term(s): ${f.sharedTerms.map((t) => `\`${t}\``).join(", ")}`);
-    for (const p of f.productions) lines.push(`      ${siteToString(p.site)}
+    lines2.push(`parseman divergent-node: \`${f.nodeType}\` is built by ${f.count} different productions sharing ${f.sharedTerms.length} term(s): ${f.sharedTerms.map((t) => `\`${t}\``).join(", ")}`);
+    for (const p of f.productions) lines2.push(`      ${siteToString(p.site)}
         ${p.shape}
         unique to it: ${p.distinctTerms.length === 0 ? "(none)" : p.distinctTerms.map((t) => `\`${t}\``).join(", ")}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.keywordRegexes) {
     const src = f.source.length > 90 ? `${f.source.slice(0, 88)}\u2026` : f.source;
-    lines.push(`parseman ${f.bug ? "BUG " : ""}keyword-regex @ ${siteToString(f.site)}: /${src}/${f.flags}${f.vocabulary ? `  [${f.words.length} literal words${f.longestFirst ? "" : ", NOT longest-first"}]` : ""}${f.hazards.length > 0 ? `  [${f.hazards.length} prefix hazard(s)${f.bug ? ", UNRESCUED" : ""}]` : ""}${f.caseFoldRisk ? "  [CASE-FOLD RISK]" : ""}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman ${f.bug ? "BUG " : ""}keyword-regex @ ${siteToString(f.site)}: /${src}/${f.flags}${f.vocabulary ? `  [${f.words.length} literal words${f.longestFirst ? "" : ", NOT longest-first"}]` : ""}${f.hazards.length > 0 ? `  [${f.hazards.length} prefix hazard(s)${f.bug ? ", UNRESCUED" : ""}]` : ""}${f.caseFoldRisk ? "  [CASE-FOLD RISK]" : ""}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.duplicates) {
-    lines.push(`parseman duplication: ${f.count}\xD7 identical ${f.size}-node shape (saves ${f.savings} nodes) \u2014 ${f.shape}`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman duplication: ${f.count}\xD7 identical ${f.size}-node shape (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.nearDuplicates) {
-    lines.push(`parseman near-duplication: ${f.count} clones of a ${f.sharedSize}-node shape differing at ONE slot (saves ${f.savings} nodes) \u2014 ${f.shape}`);
-    lines.push(`   slot: ${f.slotPath} \u2208 { ${f.variants.join(" | ")} }`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman near-duplication: ${f.count} clones of a ${f.sharedSize}-node shape differing at ONE slot (saves ${f.savings} nodes) \u2014 ${f.shape}`);
+    lines2.push(`   slot: ${f.slotPath} \u2208 { ${f.variants.join(" | ")} }`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.regexFragments) {
-    lines.push(`parseman regex-fragment: \`${f.fragment}\` (${f.branches} branches) re-spelled in ${f.count} regex() terminals`);
-    lines.push(`     at: ${sitesLine(f.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman regex-fragment: \`${f.fragment}\` (${f.branches} branches) re-spelled in ${f.count} regex() terminals`);
+    lines2.push(`     at: ${sitesLine(f.sites)}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.regexClasses) {
-    lines.push(`parseman regex-class${f.drifted ? " DRIFT" : ""}: [${f.canonical}] across ${f.count} regex() terminals${f.bmpCeiling ? "  [BMP ceiling]" : ""}`);
-    for (const v of f.variants) lines.push(`      [${v.source}]  \xD7${v.count}  ${v.delta}
+    lines2.push(`parseman regex-class${f.drifted ? " DRIFT" : ""}: [${f.canonical}] across ${f.count} regex() terminals${f.bmpCeiling ? "  [BMP ceiling]" : ""}`);
+    for (const v of f.variants) lines2.push(`      [${v.source}]  \xD7${v.count}  ${v.delta}
         ${sitesLine(v.sites)}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
   for (const f of report.overlaps) {
-    lines.push(`parseman overlap @ ${siteToString(f.site)}: arm[${f.a}] \u2229 arm[${f.b}] on ${firstSetToString(f.on)}${f.sharedPrefix === null ? "" : ` \u2014 shared prefix: ${f.sharedPrefix}`}${f.handledByStrategy ? " [sharedPrefix strategy already handles this]" : ""}`);
-    lines.push(`   fix: ${f.suggestion}`);
+    lines2.push(`parseman overlap @ ${siteToString(f.site)}: arm[${f.a}] \u2229 arm[${f.b}] on ${firstSetToString(f.on)}${f.sharedPrefix === null ? "" : ` \u2014 shared prefix: ${f.sharedPrefix}`}${f.handledByStrategy ? " [sharedPrefix strategy already handles this]" : ""}`);
+    lines2.push(`   fix: ${f.suggestion}`);
   }
-  return lines;
+  return lines2;
 }
 function duplicationFindingCount(report) {
   return report.duplicates.length + report.nearDuplicates.length + report.regexFragments.length + report.regexClasses.length + report.overlaps.length + report.rewrites.length + report.divergentNodes.length + report.structureLoss.length + report.keywordRegexes.length;
@@ -16611,11 +17196,11 @@ function reportDuplication(opt, analyze) {
     );
     return void 0;
   }
-  const lines = formatDuplicationFindings(report);
-  if (lines.length > 0) {
+  const lines2 = formatDuplicationFindings(report);
+  if (lines2.length > 0) {
     if (level === "error") throw new Error(`parseman: ${duplicationFindingCount(report)} duplication/overlap finding(s)
-${lines.join("\n")}`);
-    for (const l of lines) console.warn(l);
+${lines2.join("\n")}`);
+    for (const l of lines2) console.warn(l);
   }
   return report;
 }
@@ -16626,8 +17211,46 @@ function runDuplicationDiagnosticRules(ruleMap, opt) {
   return reportDuplication(opt, (o) => analyzeDuplicationRules(ruleMap, o));
 }
 
+// src/table/select-hot.ts
+var LOOP = 8;
+var ROUNDS = 60;
+var CAP = 1e12;
+function selectHotSites(code, entries, siteBytes, budget, profile) {
+  const selected = /* @__PURE__ */ new Set();
+  if (budget <= 0) return selected;
+  const weight = profile === void 0 ? staticWeights(code, entries) : void 0;
+  const w = (ip) => (weight !== void 0 ? weight.get(ip) : profile[ip]) ?? 0;
+  const ranked = [...siteBytes.keys()].sort((a, b) => w(b) / siteBytes.get(b) - w(a) / siteBytes.get(a) || a - b);
+  let spent = 0;
+  for (const ip of ranked) {
+    if (w(ip) === 0) break;
+    const bytes = siteBytes.get(ip);
+    if (spent + bytes > budget) continue;
+    spent += bytes;
+    selected.add(ip);
+  }
+  return selected;
+}
+function staticWeights(code, entries) {
+  let weight = /* @__PURE__ */ new Map();
+  const kids = [];
+  for (let round = 0; round < ROUNDS; round++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const ip of entries) next.set(ip, 1);
+    for (const [ip, w] of weight) {
+      kids.length = 0;
+      childSlots(code, ip, kids);
+      const op = code[ip];
+      const scale = op === OP_REP || op === OP_REPV ? LOOP : op === OP_CHOICE || op === OP_DISPATCH ? 1 / Math.max(1, kids.length) : 1;
+      for (const kid of kids) next.set(kid, Math.min(CAP, (next.get(kid) ?? 0) + w * scale));
+    }
+    weight = next;
+  }
+  return weight;
+}
+
 // src/table/compile-rule-map.ts
-var DEFAULT_PRECOMPILE_MIN_WORDS = 1024;
+var SUPERCOMPILE_GROWTH = 1.05;
 function resolveHostMode(ruleMap, explicit) {
   return explicit ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean) ?? "ast";
 }
@@ -16724,14 +17347,40 @@ function compileRuleMap(ruleMap, opts = {}) {
     entry: null,
     runtimeRef: opts.runtimeRef ?? "tableRules",
     fnSources: sources,
-    ...options.precompileDefault === true && hostMode === "ast" && prog.lines !== 1 && prog.code.length >= DEFAULT_PRECOMPILE_MIN_WORDS ? { assemblies: defaultAssemblyCfgs(artifact).slice(0, 1) } : {},
+    ...options.select !== void 0 && options.select.size > 0 ? { assemblies: [{ ...defaultAssemblyCfgs(artifact)[0], select: options.select }] } : {},
     ...metadataSource === void 0 ? {} : { metadataSource }
   });
   const replacement = replacementWithMetadata();
+  const selectAssembly = (budget, profile) => {
+    const none = { sites: /* @__PURE__ */ new Set(), bytes: 0 };
+    if (hostMode !== "ast" || prog.lines === 1) return none;
+    const table = resolveTable(artifact);
+    const cfg = defaultAssemblyCfgs(artifact)[0];
+    const roots = assemblyExtraIps(artifact);
+    let siteBytes, fixed;
+    try {
+      siteBytes = emitAssemblySource(table, artifact, cfg, roots, true).siteBytes;
+      fixed = emitAssemblySource(table, artifact, cfg, roots, true, /* @__PURE__ */ new Set()).source.length;
+    } catch (e) {
+      if (e instanceof Unemittable) return { ...none, refusal: e.construct };
+      throw e;
+    }
+    const ceiling = budget / SUPERCOMPILE_GROWTH;
+    let target = ceiling;
+    for (let attempt2 = 0; attempt2 < 16; attempt2++) {
+      const sites = selectHotSites(artifact.code, Object.values(artifact.rules), siteBytes, target - fixed, profile);
+      if (sites.size === 0) return none;
+      const bytes = emitAssemblySource(table, artifact, cfg, roots, true, sites).source.length;
+      if (bytes <= ceiling) return { sites, bytes: Math.ceil(bytes * SUPERCOMPILE_GROWTH) };
+      target *= Math.min(ceiling / bytes, 0.99);
+    }
+    return none;
+  };
   return {
     keys: ruleMap.map(([key]) => key),
     replacement,
     replacementWithMetadata,
+    selectAssembly,
     hostMode,
     // WHAT THE FLAG MEANS is "a DIRECT BUILDER's positioned-CST branch was
     // dropped", which is what the driver's `'ast' artifact + CST host` check keys
@@ -16886,7 +17535,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
   const emitOpts = { fnSources: sources };
   const source = printable ? emitTableModule(artifact, { name: "grammar", ...emitOpts }) : "";
   const inlineExpression = printable ? emitTableExpression(artifact, { entry: ENTRY, runtimeRef: opts.runtimeRef ?? "tableRules", ...emitOpts }) : null;
-  const runOnce = (input, pos, ctx) => entry(input, pos, ctx);
+  const runOnce2 = (input, pos, ctx) => entry(input, pos, ctx);
   return {
     source,
     inlineExpression,
@@ -16900,10 +17549,10 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
     // parser runs where a combinator does. A caller probing many positions
     // passes one context and pays for none per call.
     parse(input, pos = 0, ctx) {
-      return runOnce(input, pos, ctx ?? createParseContext());
+      return runOnce2(input, pos, ctx ?? createParseContext());
     },
     parseWithContext(input, parseCtx, pos = 0) {
-      return runOnce(input, pos, parseCtx);
+      return runOnce2(input, pos, parseCtx);
     },
     /**
      * NO LONGER REFUSES. It used to throw unless the caller passed
@@ -16919,7 +17568,7 @@ function compileImpl(combinator, mapFnSources, opts = {}) {
       const errors = [];
       ctx._errors = errors;
       ctx._tolerant = true;
-      const r = runOnce(input, pos, ctx);
+      const r = runOnce2(input, pos, ctx);
       return { ...r, errors };
     }
   };
@@ -16962,6 +17611,9 @@ function childrenOf3(def) {
       ];
     case "routed":
       return def.fallback ? [def.fallback] : [];
+    case "lines":
+      return [def.prefix, def.body, ...def.first === void 0 ? [] : [def.first], ...def.lazy === void 0 ? [] : [def.lazy]];
+    case "columns":
     case "lazy":
     case "literal":
     case "regex":
@@ -17291,6 +17943,15 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         return `expect(${kid(def.parser)}${def.label !== void 0 ? `, ${JSON.stringify(def.label)}` : ""})`;
       case "scanTo":
         return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(", ")}]${def.raw ? ", raw: true" : ""}, orEOF: ${def.orEOF}${def.recoverAt === void 0 ? "" : `, recoverAt: ${kid(def.recoverAt)}`}${def.stopAt === void 0 ? "" : `, stopAt: ${kid(def.stopAt)}`} })`;
+      case "lines": {
+        const options = [
+          ...def.first === void 0 ? [] : [`first: ${kid(def.first)}`],
+          ...def.lazy === void 0 ? [] : [`lazy: ${kid(def.lazy)}`]
+        ];
+        return `lines(${kid(def.prefix)}, ${kid(def.body)}${options.length === 0 ? "" : `, { ${options.join(", ")} }`})`;
+      }
+      case "columns":
+        return `columns(${def.n})`;
       case "transform": {
         if (def.fnSrc === void 0) throw new Unserializable("transform without fnSrc");
         return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)}${def.recognitionOnly ? ", true" : ""})`;
@@ -17355,7 +18016,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.55.4";
+var PARSEMAN_VERSION = "0.57.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17448,6 +18109,337 @@ function cstBuildHost(typeOrOptions, children3, _fields, span, rawChildren, triv
 cstBuildHost._parsemanCstOutput = true;
 var COMPOSED_PIECES = /* @__PURE__ */ Symbol.for("parseman.composedPieces");
 
+// src/cst/trivia-entries.ts
+var EMPTY_INDICES = Object.freeze([]);
+var EMPTY_GAPS = Object.freeze([]);
+var SELECTED_ROOT_STRIDE = 5;
+function buildRootTriviaIndex(log, labels) {
+  const length = Math.floor(log.length / SELECTED_ROOT_STRIDE);
+  const markerOffset = (i) => i * SELECTED_ROOT_STRIDE;
+  const ownedRangeStart = (i) => log[markerOffset(i)];
+  const ownedRangeEnd = (i) => log[markerOffset(i) + 1];
+  const markerStart = (i) => log[markerOffset(i) + 2];
+  const markerEnd = (i) => log[markerOffset(i) + 3];
+  const markerKind = (i) => log[markerOffset(i) + 4];
+  const entries = {
+    length,
+    labels,
+    stride: SELECTED_ROOT_STRIDE,
+    start: markerStart,
+    end: markerEnd,
+    insertIndex: () => void 0,
+    kindIndex: markerKind,
+    kind(i) {
+      return labels[markerKind(i)];
+    },
+    text(i, input) {
+      return input.slice(markerStart(i), markerEnd(i));
+    }
+  };
+  const lowerBound = (offset, by) => {
+    let lo = 0;
+    let hi = length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (by(mid) < offset) lo = mid + 1;
+      else hi = mid;
+    }
+    return lo;
+  };
+  const gapRowsAt = (offset, direction) => {
+    const edge = direction === "before" ? ownedRangeEnd : ownedRangeStart;
+    let first = lowerBound(offset, edge);
+    if (first === length || edge(first) !== offset) return void 0;
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    while (first > 0 && ownedRangeStart(first - 1) === start && ownedRangeEnd(first - 1) === end) first--;
+    let last = first + 1;
+    while (last < length && ownedRangeStart(last) === start && ownedRangeEnd(last) === end) last++;
+    return [first, last];
+  };
+  const indices = (first, last) => {
+    const out = [];
+    for (let i = first; i < last; i++) out.push(i);
+    return out;
+  };
+  const makeGap = (first, last) => {
+    const start = ownedRangeStart(first);
+    const end = ownedRangeEnd(first);
+    let entryIndices;
+    return {
+      start,
+      end,
+      get entryIndices() {
+        return entryIndices ??= indices(first, last);
+      },
+      hasKind(kind) {
+        for (let i = first; i < last; i++) {
+          if (labels[markerKind(i)] === kind) return true;
+        }
+        return false;
+      },
+      text(input) {
+        return input.slice(start, end);
+      }
+    };
+  };
+  let maps;
+  const getMaps = () => {
+    if (maps !== void 0) return maps;
+    const before = /* @__PURE__ */ new Map();
+    const after = /* @__PURE__ */ new Map();
+    const beforeGaps = /* @__PURE__ */ new Map();
+    const afterGaps = /* @__PURE__ */ new Map();
+    const gaps = [];
+    for (let first = 0; first < length; ) {
+      let last = first + 1;
+      while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+      const gap = makeGap(first, last);
+      gaps.push(gap);
+      afterGaps.set(gap.start, gap);
+      beforeGaps.set(gap.end, gap);
+      after.set(gap.start, [...gap.entryIndices]);
+      before.set(gap.end, [...gap.entryIndices]);
+      first = last;
+    }
+    maps = { before, after, beforeGaps, afterGaps, gaps };
+    return maps;
+  };
+  return {
+    entries,
+    labels,
+    get before() {
+      return getMaps().before;
+    },
+    get after() {
+      return getMaps().after;
+    },
+    entryIndicesBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    entryIndicesAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? indices(rows[0], rows[1]) : EMPTY_INDICES;
+    },
+    gapBefore(offset) {
+      const rows = gapRowsAt(offset, "before");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gapAfter(offset) {
+      const rows = gapRowsAt(offset, "after");
+      return rows ? makeGap(rows[0], rows[1]) : void 0;
+    },
+    gaps() {
+      return getMaps().gaps;
+    },
+    gapsWithKind(kind) {
+      const kinds = typeof kind === "string" ? [kind] : kind;
+      const matches2 = [];
+      for (let first = 0; first < length; ) {
+        let last = first + 1;
+        while (last < length && ownedRangeStart(last) === ownedRangeStart(first) && ownedRangeEnd(last) === ownedRangeEnd(first)) last++;
+        let matched = false;
+        for (let i = first; i < last && !matched; i++) {
+          const label2 = labels[markerKind(i)];
+          for (const kind2 of kinds) {
+            if (label2 === kind2) {
+              matched = true;
+              break;
+            }
+          }
+        }
+        if (matched) matches2.push(makeGap(first, last));
+        first = last;
+      }
+      return matches2.length === 0 ? EMPTY_GAPS : matches2;
+    }
+  };
+}
+
+// src/functional/run.ts
+var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
+var REMOVED_RUN_RESULT_FIELDS = [
+  [
+    "triviaMap",
+    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
+  ],
+  [
+    "triviaLog",
+    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
+  ],
+  [
+    "triviaKindLabels",
+    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
+  ]
+];
+var RunResultRecord = class {
+  constructor(ok, value, span, expected, errors, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+var RunResultWithRootTrivia = class {
+  constructor(ok, value, span, expected, errors, rootTrivia, unconsumedFrom) {
+    this.ok = ok;
+    this.value = value;
+    this.span = span;
+    this.expected = expected;
+    this.errors = errors;
+    this.rootTrivia = rootTrivia;
+    this.unconsumedFrom = unconsumedFrom;
+  }
+};
+for (const proto of [RunResultRecord.prototype, RunResultWithRootTrivia.prototype]) {
+  for (const [name, detail] of REMOVED_RUN_RESULT_FIELDS) {
+    Object.defineProperty(proto, name, {
+      configurable: true,
+      enumerable: false,
+      get() {
+        throw new TypeError(
+          `RunResult.${name} was REMOVED in parseman 0.44.0 and has no default replacement. ${detail}`
+        );
+      }
+    });
+  }
+}
+var invoke = (r, input, pos, ctx) => typeof r === "function" ? r(input, pos, ctx) : r.parse(input, pos, ctx);
+function ambientTriviaFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.grammarTrivia;
+  if (r._meta.isTrivia) return void 0;
+  return r._meta.grammarTrivia ?? (r._def.tag === "grammar" ? r._def.triviaParser : void 0);
+}
+function triviaKindLabelsFromRunnable(r) {
+  if (!r) return void 0;
+  if (typeof r === "function") return r._meta?.triviaKindLabels;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.triviaKindLabels ?? r._meta.triviaKindLabels ?? (r._def.tag === "grammar" ? r._def.triviaParser?._meta.triviaKindLabels : void 0);
+}
+function rootTriviaClassifiedFromRunnable(r) {
+  if (!r) return false;
+  if (typeof r === "function") return r._meta?.rootTriviaClassified === true;
+  const grammarTrivia = r._meta.grammarTrivia;
+  return grammarTrivia?._meta.rootTriviaClassified === true || r._meta.rootTriviaClassified === true;
+}
+function makeSelectedRootLabelIndex(labels) {
+  const index = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < labels.length; i++) {
+    if (index[labels[i]] === void 0) index[labels[i]] = i;
+  }
+  return index;
+}
+function growSpanEnd(span, input, end) {
+  if (span.endLine === void 0 || span.endColumn === void 0) {
+    return { start: span.start, end };
+  }
+  let line = span.endLine;
+  let column = span.endColumn;
+  for (let i = span.end; i < end; i++) {
+    if (input.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { ...span, end, endLine: line, endColumn: column };
+}
+function runOnce(entry, input, options) {
+  if (typeof entry !== "function" && typeof entry?.parse !== "function") {
+    throw new TypeError(
+      `run(): start production is ${entry === null ? "null" : typeof entry}, not a rule \u2014 the requested grammar rule does not exist (check the rule name).`
+    );
+  }
+  const rootTriviaSelection = options.rootTrivia?.select;
+  const captureRootTrivia = rootTriviaSelection !== void 0 && rootTriviaSelection.length > 0;
+  const selectedRootLog = captureRootTrivia ? [] : void 0;
+  const selectedRootLabelIndex = captureRootTrivia ? makeSelectedRootLabelIndex(rootTriviaSelection) : void 0;
+  const errors = [];
+  const grammarTrivia = typeof entry !== "function" ? entry._meta.grammarTrivia : void 0;
+  const grammarScanSkip = typeof entry !== "function" ? entry._meta.grammarScanSkip : void 0;
+  const triviaKindLabels = triviaKindLabelsFromRunnable(entry) ?? triviaKindLabelsFromRunnable(options.trivia);
+  if (captureRootTrivia && triviaKindLabels === void 0) {
+    throw new TypeError("run(): rootTrivia.select requires labeled grammar trivia.");
+  }
+  if (captureRootTrivia) {
+    for (const label2 of rootTriviaSelection) {
+      if (!triviaKindLabels.includes(label2)) {
+        throw new TypeError(`run(): rootTrivia.select contains unknown trivia label ${JSON.stringify(label2)}.`);
+      }
+    }
+  }
+  if (captureRootTrivia && !rootTriviaClassifiedFromRunnable(entry) && !rootTriviaClassifiedFromRunnable(options.trivia)) {
+    throw new TypeError(
+      "run(): rootTrivia.select requires classifiedTrivia() at the root."
+    );
+  }
+  const stamped = entry;
+  assertHostModeCompatible(
+    typeof entry === "function" ? stamped[FUSED_HOST_MODE] ?? "ast" : entry._meta.grammarHostMode ?? "ast",
+    options.build,
+    typeof entry === "function" && stamped[FUSED_HOST_ELIDED] === true
+  );
+  const ctx = createParseContext();
+  if (captureRootTrivia) {
+    ctx._rootTriviaLog = selectedRootLog;
+    ctx._rootTriviaKindIndex = selectedRootLabelIndex;
+    ctx._rootTriviaStrictScopes = true;
+  }
+  ctx._errors = errors;
+  ctx.build = options.build;
+  ctx.state = options.state;
+  if (grammarTrivia !== void 0) ctx.trivia = grammarTrivia;
+  if (triviaKindLabels) ctx.triviaKindLabels = triviaKindLabels;
+  if (grammarScanSkip !== void 0) ctx.scanSkip = grammarScanSkip;
+  if (options.triviaCaptureMask !== void 0) ctx._triviaCaptureMask = options.triviaCaptureMask;
+  if (options.tolerant) {
+    ctx._tolerant = true;
+    ctx._rec = REC;
+  }
+  if (options.instrumentation !== void 0) {
+    ctx._grammarCoverage = options.instrumentation._grammarCoverage;
+    ctx._grammarTrace = options.instrumentation._grammarTrace;
+  }
+  const r = invoke(entry, input, 0, ctx);
+  const value = r.ok ? r.value : void 0;
+  let span = r.span ?? { start: 0, end: 0 };
+  const expected = r.ok ? [] : r.expected ?? [];
+  let unconsumedFrom = null;
+  if (r.ok) {
+    let pos = span.end;
+    const tail = options.trivia ?? ambientTriviaFromRunnable(entry);
+    if (tail !== void 0 && pos < input.length) {
+      const t = invoke(tail, input, pos, createParseContext());
+      if (t.ok && t.span.end > pos) {
+        span = growSpanEnd(span, input, t.span.end);
+        pos = t.span.end;
+      }
+    }
+    unconsumedFrom = pos < input.length ? pos : null;
+  }
+  return selectedRootLog !== void 0 && selectedRootLog.length > 0 ? new RunResultWithRootTrivia(
+    r.ok,
+    value,
+    span,
+    expected,
+    errors,
+    {
+      rows: selectedRootLog,
+      select: rootTriviaSelection,
+      index: buildRootTriviaIndex(selectedRootLog, rootTriviaSelection)
+    },
+    unconsumedFrom
+  ) : new RunResultRecord(r.ok, value, span, expected, errors, unconsumedFrom);
+}
+function run(entry, input, options = {}) {
+  return runOnce(entry, input, options);
+}
+
 // src/combinators/gate.ts
 function gate(predicate) {
   const meta = {
@@ -17882,6 +18874,10 @@ var SUPPORTED = {
   field: (...a) => field(a[0], a[1], a[2]),
   noTrivia: (...a) => noTrivia(a[0]),
   token: (...a) => token(a[0]),
+  // `lines(prefix, body, { first, lazy })`: its options are combinators, which the
+  // generic argument evaluation already resolves; a missing option stays absent.
+  lines: (...a) => lines(a[0], a[1], a[2]),
+  columns: (...a) => columns(a[0]),
   // `routed(fallback)` — the fallback must be forwarded. A zero-arg entry here read
   // as "routed takes no arguments" and SILENTLY built a bare `routed()`, so a
   // production written to work both inside and outside a dispatch branch lost its
@@ -19519,19 +20515,14 @@ function fallback(emitted, reason, before) {
     }
   };
 }
-function supercompileRuleMapReplacement(prog, replacement) {
+function supercompileRuleMapReplacement(prog, replacement, select) {
   const cfg = defaultAssemblyCfgs(prog)[0];
   if (cfg === void 0) return replacement;
-  const extraIps = [];
-  for (const scan of prog.scans ?? []) {
-    for (const ref2 of scan.skip) extraIps.push(ref2[0]);
-    if (scan.sentinel !== void 0) extraIps.push(scan.sentinel[0]);
-  }
-  for (const set of prog.scanSkip ?? []) for (const ref2 of set) extraIps.push(ref2[0]);
+  const extraIps = assemblyExtraIps(prog);
   let canonical2;
   let candidate;
   try {
-    canonical2 = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true);
+    canonical2 = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true, select);
     candidate = supercompileEmittedAssembly(prog, cfg, extraIps, canonical2);
   } catch {
     return replacement;
@@ -19834,6 +20825,7 @@ ${nested}
 }
 
 // src/plugin/ir-eval.ts
+var INERT_BUILDER = /* @__PURE__ */ Symbol("parseman.inertBuilder");
 function evalRulesIR(ir) {
   return evalIR(ir, rules);
 }
@@ -19873,9 +20865,11 @@ function evalIR(ir, rulesImpl) {
     if (staticError !== void 0 && staticError.length > 0) {
       throw new Error(`IR direct node builder for ${type} must be macro-static and self-contained; unsupported binding(s): ${staticError.join(", ")}`);
     }
-    const n = node(type, child, (() => {
+    const inert = (() => {
       throw new Error("IR node build requires static re-lowering");
-    }), opts);
+    });
+    inert[INERT_BUILDER] = type;
+    const n = node(type, child, inert, opts);
     n._def.buildSrc = src;
     if (staticError !== void 0) n._def.buildStaticError = staticError;
     if (sigSrc !== void 0) n._def.buildSigSrc = sigSrc;
@@ -19964,6 +20958,8 @@ function evalIR(ir, rulesImpl) {
     "_nd",
     "_gch",
     "_wc",
+    "lines",
+    "columns",
     `return (${ir})`
   );
   return fn(
@@ -20007,14 +21003,28 @@ function evalIR(ir, rulesImpl) {
     _lf,
     _nd,
     _gch,
-    _wc
+    _wc,
+    lines,
+    columns
   );
 }
 
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var TABLE_RUNTIME_SPECIFIER = "parseman/table";
+var corpusCache = /* @__PURE__ */ new Map();
+function corpusTexts(profile) {
+  return profile.files.map((file) => {
+    const mtimeMs = fs2.statSync(file).mtimeMs;
+    const hit = corpusCache.get(file);
+    if (hit !== void 0 && hit.mtimeMs === mtimeMs) return hit.text;
+    const text = fs2.readFileSync(file, "utf8");
+    corpusCache.set(file, { mtimeMs, text });
+    return text;
+  });
+}
 var PARSEMAN_MODULE = "parseman";
+var DEFAULT_ASSEMBLY_BUDGET = 0.25;
 function reasonSuffix(runtimeOnly) {
   return runtimeOnly === void 0 || runtimeOnly.length === 0 ? "" : ` \u2014 ${runtimeOnly.join("; ")}`;
 }
@@ -20132,8 +21142,9 @@ var plugin_default = createUnplugin((opts = {}) => ({
   transform(code, id) {
     if (!code.includes("parseman")) return null;
     if (!code.includes("macro")) return null;
+    for (const file of opts.assemblyProfile?.files ?? []) this?.addWatchFile?.(file);
     const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
-    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true);
+    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true, opts.recovery === true, opts.grammarCoverage === true, opts.assemblyProfile, opts.assemblyBudget);
     if (result?.warnings.length) {
       for (const w of result.warnings) {
         if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
@@ -20289,17 +21300,17 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
     _sourceLowering.delete(file);
   }
 }
-function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false) {
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false, recovery = false, grammarCoverage = false, assemblyProfile, assemblyBudget = DEFAULT_ASSEMBLY_BUDGET) {
   const depth = degradationCaptureDepth();
   try {
-    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage);
+    return transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudget);
   } finally {
     setReducerResolver(null);
     setBuilderImportResolver(null);
     for (const d of unwindDegradationCapture(depth)) console.warn(formatDegradation(d));
   }
 }
-function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage) {
+function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage, assemblyProfile, assemblyBudgetShare) {
   let result;
   try {
     result = parseSync5(id, code);
@@ -21125,9 +22136,10 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
           carried,
           reflection: compiled.reflection
         });
+        const select = selectAssembly(init.start, "compose()", compiled, !declaresLeaf());
         return {
-          replacement: compiled.replacementWithMetadata(reflectionMetadata),
-          exportedReplacement: compiled.replacementWithMetadata(exportedMetadata),
+          replacement: assembledReplacement(compiled, reflectionMetadata, select),
+          exportedReplacement: assembledReplacement(compiled, exportedMetadata, select),
           carried,
           ...composing ? { trivia: composing } : {},
           ...importedFactories.length ? { importedFactories } : {},
@@ -21143,6 +22155,42 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
     warn(init.start, "compose(): a carried piece has no re-lowerable IR; leaving the runtime compose() in place");
     return null;
   };
+  let assemblyBudget = Math.floor(code.length * assemblyBudgetShare);
+  let leafDeclared;
+  const declaresLeaf = () => leafDeclared ??= body.some((stmt) => {
+    const vd = unwrapVd(stmt);
+    return vd !== null && vd.declarations.some((d) => d.init != null && isComposeLeafCall(d.init));
+  });
+  const selectAssembly = (pos, label2, compiled, terminal) => {
+    if (!terminal || grammarCoverage) return /* @__PURE__ */ new Set();
+    const { sites, bytes, refusal } = compiled.selectAssembly(assemblyBudget, profileOf(compiled));
+    if (refusal !== void 0) {
+      warnings.push(`${id}:${lineOf(pos)} \u2014 ${label2}: its precompiled assembly cannot emit ${refusal}; the artifact runs on the closure engine`);
+    }
+    assemblyBudget -= bytes;
+    return sites;
+  };
+  const profileOf = (compiled) => {
+    if (assemblyProfile === void 0 || compiled.hostMode !== "ast" || compiled.prog.lines === 1 || !(assemblyProfile.entry in compiled.prog.rules)) return void 0;
+    let parsed = 0;
+    const fns = compiled.prog.fns.map((fn) => {
+      const type = fn?.[INERT_BUILDER];
+      return type === void 0 ? fn : (children3, _fields, span) => ({ type, span, children: children3 });
+    });
+    const counts = countSiteVisits(compiled.prog, (rules2) => {
+      const entry = rules2[assemblyProfile.entry];
+      for (const text of corpusTexts(assemblyProfile)) {
+        try {
+          if (run(entry, text).ok) parsed++;
+        } catch {
+        }
+      }
+    }, fns);
+    if (parsed > 0) return counts;
+    warnings.push(`${id} \u2014 assemblyProfile: no corpus file parsed from rule "${assemblyProfile.entry}"; using the static ranking`);
+    return void 0;
+  };
+  const assembledReplacement = (compiled, metadata, select) => select.size === 0 ? compiled.replacementWithMetadata(metadata) : supercompileRuleMapReplacement(compiled.prog, compiled.replacementWithMetadata(metadata, { select }), select);
   const compileComposeLeafCall = (init) => {
     const args = init.arguments;
     const arr = args[0];
@@ -21221,12 +22269,10 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         if (compiled !== null) {
           usedTableRuntime = true;
           return {
-            replacement: supercompileRuleMapReplacement(
-              compiled.prog,
-              compiled.replacementWithMetadata(
-                staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
-                { precompileDefault: true }
-              )
+            replacement: assembledReplacement(
+              compiled,
+              staticTableMetadataSource({ reflection: compiled.reflection, leaf: true }),
+              selectAssembly(init.start, "composeLeaf()", compiled, true)
             ),
             ...importedFactories.length ? { importedFactories } : {}
           };
@@ -21478,14 +22524,14 @@ ${names.map((n) => `  - ${n}`).join("\n")}` : " (it is not a static combinator/v
         }
         if (!allOk) continue;
         const holderVar = `__rules${ruleMapHolderCounter++}`;
-        const lines = [
+        const lines2 = [
           `const ${holderVar} = ${compiledRules.replacement}`,
           ...bindings.map(({ ruleKey, localName }) => `${exportPrefix}${kind} ${localName} = ${holderVar}[${JSON.stringify(ruleKey)}]`)
         ];
         replacements.push({
           start: stmtStart,
           end: stmtEnd,
-          replacement: lines.join("\n")
+          replacement: lines2.join("\n")
         });
         markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
       }
@@ -21645,12 +22691,12 @@ ${free.map(where).join("\n")}${cause}`
   setBuilderImportResolver(null);
   const degradations = endDegradationCapture();
   if (degradations.length > 0) {
-    const lines = formatDegradations(degradations);
+    const lines2 = formatDegradations(degradations);
     if (resolveDegradationLevel() === "error") {
       throw new Error(`parseman: ${degradations.length} degraded compilation path(s) in ${id}
-${lines.join("\n")}`);
+${lines2.join("\n")}`);
     }
-    for (const l of lines) warnings.push(`${id}: ${l}`);
+    for (const l of lines2) warnings.push(`${id}: ${l}`);
   }
   return {
     code: ms.toString(),