parseman 0.56.0 → 0.57.0

package/dist/plugin/index.js

@@ -366,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;
@@ -816,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,
@@ -869,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;
@@ -1415,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) {
@@ -2831,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;
@@ -3185,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) {
@@ -4821,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;
@@ -4978,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);
@@ -5019,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);
@@ -5594,7 +5641,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
     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) => {
+    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) {
@@ -5604,7 +5651,7 @@ function buildLexProgramRunner(spec, matchers, classes, expected) {
       }
       return result.span.end;
     };
-    return Object.assign(run, { scan: spec[2] });
+    return Object.assign(run2, { scan: spec[2] });
   }
   if (spec[0] === 2) return fixedTreeRunner(spec.slice(2), matchers, classes, expected);
   if (spec[0] === 1) {
@@ -5732,6 +5779,12 @@ function scanRefs(s) {
   refs.push(...s.skip);
   return refs;
 }
+function assemblyExtraIps(prog) {
+  const ips = [];
+  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) ips.push(r[0]);
+  for (const set of prog.scanSkip ?? []) for (const r of set) ips.push(r[0]);
+  return ips;
+}
 function expandCompact(p) {
   if ("code" in p) return p;
   return ownTableProgram({
@@ -5862,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 = [];
@@ -7442,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;
@@ -7453,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`).
@@ -7763,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;
@@ -7792,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);
@@ -7816,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;
       }
@@ -7864,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;
@@ -7957,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":
@@ -7978,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);
@@ -9710,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
@@ -9731,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}})}
@@ -9938,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)];
@@ -10013,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 = [];
@@ -10037,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 = [];
@@ -10172,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;
@@ -10182,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;
     }
@@ -10228,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) {
@@ -10370,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: {
@@ -10435,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
 }`;
@@ -10556,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
@@ -10574,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
@@ -10593,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}})
@@ -10604,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)}
@@ -10633,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}
@@ -10647,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}
@@ -10657,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){
@@ -10687,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")}
 }`;
@@ -10708,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;
@@ -10741,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
@@ -10768,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) => {
@@ -10793,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);
@@ -10810,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();
@@ -10822,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}){
@@ -10836,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");
@@ -10949,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
 }
@@ -11041,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}))`;
@@ -11089,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)
@@ -11104,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
@@ -11143,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
 }
@@ -11274,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) {
@@ -11335,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}}
@@ -11348,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++
@@ -11389,7 +11556,7 @@ pieces:{${ruleEntries.join(",")}},
 byIp:{${extra.join(",")}},
 end:function(){return EC.e},
 begin:_begin,
-finish:_finish
+finish:_finish${hybrid}
 }`;
   return {
     source,
@@ -11397,6 +11564,7 @@ finish:_finish
     masks,
     classes,
     armExpected,
+    siteBytes,
     plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
   };
 }
@@ -11495,20 +11663,20 @@ function lines(prefix, body, options = {}) {
       const c = ctx;
       const probe = createDetachedParseContext(false, ctx.state);
       probe.lineView = c.lineView;
-      const run = [];
+      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 = (run.length === 0 ? opening : prefix).parse(input, start, probe);
+        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 (run.length === 0) {
+        } 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;
@@ -11517,7 +11685,7 @@ function lines(prefix, body, options = {}) {
         const mark = probe._columnsSplit;
         const here = columnAt(input, content, c);
         const split = joined === "prefix" && mark !== void 0 && mark.at === content ? mark.split : here.split;
-        run.push({ offset, source: content, end: end2, column: here.column + (split - here.split), split, lazy: joined === "lazy" });
+        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}
@@ -11526,11 +11694,11 @@ function lines(prefix, body, options = {}) {
         start = end2 + 1;
         if (!newline) break;
       }
-      const view = { lines: run, parent: c.lineView };
+      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 run) {
+      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;
@@ -11563,8 +11731,8 @@ function lines(prefix, body, options = {}) {
       }
       const stop = result.span.end;
       const index = lineIndexAt(view, stop);
-      const line = run[index];
-      const end = stop === line.offset && index > 0 ? run[index - 1].end + 1 : stop - line.offset > line.end - line.source ? line.end + 1 : line.source + (stop - line.offset);
+      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 } };
     }
@@ -11827,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];
@@ -11863,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");
@@ -12008,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;
@@ -12023,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];
@@ -12032,15 +12280,23 @@ function assemble(t, prog, cfg) {
     }
     return recognize;
   }
-  const labelExtraIps = [];
-  for (const s of prog.scans ?? []) for (const r of scanRefs(s)) labelExtraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) labelExtraIps.push(r[0]);
+  const labelExtraIps = assemblyExtraIps(prog);
   const closureLabels = computeSiteLabels(
     code,
     [...Object.values(prog.rules), ...labelExtraIps],
     hostCst
   );
   let SCAN = null;
+  let HYBRID;
+  function hybridPiece(piece) {
+    const setScan = HYBRID.scan;
+    return (input, pos, ctx) => {
+      const saved = setScan(SCAN);
+      const value = piece(input, pos, ctx);
+      setScan(saved);
+      return value;
+    };
+  }
   const memo = /* @__PURE__ */ new Map();
   const reached = /* @__PURE__ */ new Set();
   function pushLeaf(ctx, value, s, e) {
@@ -12332,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;
@@ -12504,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;
@@ -12587,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;
@@ -12666,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) => {
@@ -12673,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);
@@ -13014,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;
@@ -13210,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;
@@ -13233,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;
@@ -13255,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;
@@ -13353,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;
@@ -13375,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;
@@ -13396,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 } });
@@ -13498,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) => {
@@ -13967,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;
@@ -14062,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);
@@ -14192,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);
@@ -14370,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;
           }
@@ -14428,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) => {
@@ -14776,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]);
@@ -14789,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);
             }
@@ -14843,9 +15125,7 @@ function assemble(t, prog, cfg) {
   let emitRefusal;
   let emitReached;
   {
-    const extraIps = [];
-    for (const s of prog.scans ?? []) for (const r of scanRefs(s)) extraIps.push(r[0]);
-    for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+    const extraIps = assemblyExtraIps(prog);
     const roots = [...Object.values(prog.rules), ...extraIps];
     for (const ip of reachableSites(code, roots)) {
       if (code[ip] === OP_DISPATCH) {
@@ -14926,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,
@@ -14938,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();
@@ -15010,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,
@@ -15022,7 +15304,8 @@ function assemble(t, prog, cfg) {
         adjacencyHolds,
         t.lexPrograms,
         LEAD,
-        triviaFieldCapture
+        triviaFieldCapture,
+        skipDeferredTrivia
       );
       emitReached = em.reached;
     } catch (e) {
@@ -15033,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;
@@ -15063,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 {
@@ -15098,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;
@@ -15311,9 +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 scanRefs(s)) extraIps.push(r[0]);
-  for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+  const extraIps = assemblyExtraIps(prog);
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   for (const cfg of cfgs) {
@@ -15322,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;
@@ -16117,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.`
@@ -16879,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";
 }
@@ -16977,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
@@ -17139,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,
@@ -17153,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
@@ -17172,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 };
     }
   };
@@ -17620,7 +18016,7 @@ function fieldOptionsSrc(def) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.56.0";
+var PARSEMAN_VERSION = "0.57.0";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {
@@ -17713,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 = {
@@ -19788,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;
@@ -20103,6 +20825,7 @@ ${nested}
 }
 
 // src/plugin/ir-eval.ts
+var INERT_BUILDER = /* @__PURE__ */ Symbol("parseman.inertBuilder");
 function evalRulesIR(ir) {
   return evalIR(ir, rules);
 }
@@ -20142,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;
@@ -20287,7 +21012,19 @@ function evalIR(ir, rulesImpl) {
 // 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("; ")}`;
 }
@@ -20405,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}`);
@@ -20562,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);
@@ -21398,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 } : {},
@@ -21416,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];
@@ -21494,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 } : {}
           };