parseman 0.47.0 → 0.47.1

package/dist/table/index.js

@@ -44,6 +44,13 @@ function empty() {
 function matchesEmpty(p, seen = /* @__PURE__ */ new Set(), resolve) {
   if (seen.has(p)) return true;
   seen.add(p);
+  try {
+    return matchesEmptyBody(p, seen, resolve);
+  } finally {
+    seen.delete(p);
+  }
+}
+function matchesEmptyBody(p, seen, resolve) {
   const me = (c) => matchesEmpty(c, seen, resolve);
   const d = p._def;
   switch (d.tag) {
@@ -145,6 +152,13 @@ function sequenceFirstSet(parsers) {
 function firstSetOf(p, seen = /* @__PURE__ */ new Set(), resolve) {
   if (seen.has(p)) return any();
   seen.add(p);
+  try {
+    return firstSetBody(p, seen, resolve);
+  } finally {
+    seen.delete(p);
+  }
+}
+function firstSetBody(p, seen, resolve) {
   const fs = (c) => firstSetOf(c, seen, resolve);
   const empties = (c) => matchesEmpty(c, /* @__PURE__ */ new Set(), resolve);
   const d = p._def;
@@ -1471,6 +1485,23 @@ function rollbackTrivia(ctx, mark) {
   if (ctx._triviaLog && ctx._triviaLog.length !== mark.log) ctx._triviaLog.length = mark.log;
   if (ctx._rootTriviaLog && ctx._rootTriviaLog.length !== mark.rootLog) ctx._rootTriviaLog.length = mark.rootLog;
 }
+function removeNumberRange(values, start, end) {
+  if (values === void 0 || end <= start) return;
+  if (values.length > end) values.copyWithin(start, end);
+  values.length -= end - start;
+}
+function rollbackScannedTriviaAt(ctx, tlogStart, tlogEnd, logStart, logEnd, rootLogStart, rootLogEnd) {
+  const b = ctx._cstBuf;
+  if (b !== void 0) {
+    const tlog = b.tl;
+    removeNumberRange(tlog, tlogStart, tlogEnd);
+    if (tlog !== void 0 && tlog.length === 0) b.tl = void 0;
+  } else {
+    removeNumberRange(ctx._cstTriviaLog, tlogStart, tlogEnd);
+  }
+  removeNumberRange(ctx._triviaLog, logStart, logEnd);
+  removeNumberRange(ctx._rootTriviaLog, rootLogStart, rootLogEnd);
+}
 function parseTriviaNoCapture(triviaP, input, cur, ctx) {
   const probeCtx = createDetachedParseContext(ctx.trackLines, ctx.state);
   probeCtx._lineIndex = ctx._lineIndex;
@@ -2130,7 +2161,9 @@ function sequence(...parsers) {
           continue;
         }
         if (ctx.trivia && i > 0) {
-          const mark = saveTriviaMark(ctx);
+          const mTlog = cstTlLen(ctx);
+          const mLog = ctx._triviaLog?.length ?? 0;
+          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           let scanEnd;
           if (needsDeferredTriviaCommit(ctx)) {
             const scan = scanTrivia(input, cur, ctx);
@@ -2139,10 +2172,13 @@ function sequence(...parsers) {
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
+          const scanTlog = cstTlLen(ctx);
+          const scanLog = ctx._triviaLog?.length ?? 0;
+          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
           const result2 = parsers[i].parse(input, scanEnd, ctx);
           if (!result2.ok) return result2;
           if (result2.span.end > scanEnd) cur = result2.span.end;
-          else rollbackTrivia(ctx, mark);
+          else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
           if (values !== void 0) values.push(result2.value);
           continue;
         }
@@ -2173,7 +2209,9 @@ function sequence(...parsers) {
       }
       if (ctx.trivia && i > 0) {
         let scanEnd;
-        const mark = saveTriviaMark(ctx);
+        const mTlog = cstTlLen(ctx);
+        const mLog = ctx._triviaLog?.length ?? 0;
+        const mRootLog = ctx._rootTriviaLog?.length ?? 0;
         if (needsDeferredTriviaCommit(ctx)) {
           const scan = scanTrivia(input, cur, ctx);
           scan.commit();
@@ -2181,10 +2219,13 @@ function sequence(...parsers) {
         } else {
           scanEnd = advanceTrivia(input, cur, ctx);
         }
+        const scanTlog = cstTlLen(ctx);
+        const scanLog = ctx._triviaLog?.length ?? 0;
+        const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
         const result2 = parsers[i].parse(input, scanEnd, ctx);
         if (!result2.ok) return result2;
         if (result2.span.end > scanEnd) cur = result2.span.end;
-        else rollbackTrivia(ctx, mark);
+        else rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
         if (values !== void 0) values.push(result2.value);
         continue;
       }
@@ -2212,7 +2253,9 @@ function sequence(...parsers) {
       for (let i = 0; i < parsers.length; i++) {
         if (ctx.trivia && i > 0) {
           let scanEnd;
-          let mark = saveTriviaMark(ctx);
+          const mTlog = cstTlLen(ctx);
+          const mLog = ctx._triviaLog?.length ?? 0;
+          const mRootLog = ctx._rootTriviaLog?.length ?? 0;
           if (needsDeferredTriviaCommit(ctx)) {
             const scan = scanTrivia(input, cur, ctx);
             scan.commit();
@@ -2220,12 +2263,15 @@ function sequence(...parsers) {
           } else {
             scanEnd = advanceTrivia(input, cur, ctx);
           }
+          const scanTlog = cstTlLen(ctx);
+          const scanLog = ctx._triviaLog?.length ?? 0;
+          const scanRootLog = ctx._rootTriviaLog?.length ?? 0;
           const result2 = parsers[i].parse(input, scanEnd, ctx);
           if (!result2.ok) return result2;
           if (result2.span.end > scanEnd) {
             cur = result2.span.end;
           } else {
-            rollbackTrivia(ctx, mark);
+            rollbackScannedTriviaAt(ctx, mTlog, scanTlog, mLog, scanLog, mRootLog, scanRootLog);
           }
           if (values !== void 0) values.push(result2.value);
           continue;
@@ -3559,6 +3605,7 @@ var OP_LIVE = 37;
 var OP_ATTEMPT = 38;
 var OP_LABEL = 39;
 var OP_COV = 40;
+var OP_SCOPE_PLAIN = 41;
 var OP_DISPATCH = 25;
 var OP_ROUTED = 26;
 var OP_NAMES = {
@@ -3601,515 +3648,844 @@ var OP_NAMES = {
   [OP_LIVE]: "LIVE",
   [OP_ATTEMPT]: "ATTEMPT",
   [OP_LABEL]: "LABEL",
-  [OP_COV]: "COV"
+  [OP_COV]: "COV",
+  [OP_SCOPE_PLAIN]: "SCOPE_PLAIN"
 };
 
-// src/table/scan-shapes.ts
-var BACKSLASH = 92;
-var META2 = new Set("()[]{}*+?|^$.".split(""));
-function classToRanges(cls) {
-  if (cls === "\\d") return shorthandRanges("d");
-  if (cls === "\\w") return shorthandRanges("w");
-  if (cls === "\\s") return shorthandRanges("s");
-  const body = cls.slice(1, -1);
-  if (body.startsWith("^")) return null;
-  return parseClassRanges(body);
+// src/table/program.ts
+function closureArtifact(prog) {
+  return { ...prog, asm: [] };
 }
-var foldEq = (cVar, cp) => {
-  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`;
-  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`;
-  return `${cVar} === ${cp}`;
-};
-function parseStringShape(source) {
-  const q2 = source[0];
-  if (q2 === void 0 || q2 === "\\" || META2.has(q2)) return null;
-  if (source.length < 3 || source[source.length - 1] !== q2) return null;
-  const inner = source.slice(1, -1);
-  const CLS = String.raw`\[\^((?:\\.|[^\]])+)\]`;
-  const ESC = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
-  let body;
-  let esc;
-  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC}\\)\\*$`).exec(inner);
-  if (m) {
-    body = m[1];
-    esc = m[2];
-  } else {
-    m = new RegExp(`^\\((?:\\?:)?${ESC}\\|${CLS}\\)\\*$`).exec(inner);
-    if (m) {
-      esc = m[1];
-      body = m[2];
-    }
+function covKindCode(kind) {
+  switch (kind) {
+    case "rule":
+      return 0;
+    case "choice-arm":
+      return 1;
+    case "dispatch-arm":
+      return 2;
+    case "label":
+      return 3;
   }
-  if (body === void 0 || esc === void 0) return null;
-  const excluded = parseClassRanges(body);
-  if (!excluded) return null;
-  const qcp = q2.codePointAt(0);
-  const inSet = (cp) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi);
-  if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
-  return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
 }
-function parseSeqParts(source) {
-  const parts = [];
-  let lit = [];
-  const flush = () => {
-    if (lit.length) {
-      parts.push({ part: "lit", cps: lit, optional: false });
-      lit = [];
-    }
-  };
-  const braceQuant = (at) => {
-    const close = source.indexOf("}", at);
-    if (close === -1) return null;
-    const body = source.slice(at + 1, close);
-    const m = /^(\d+)(,(\d*)?)?$/.exec(body);
-    if (!m) return null;
-    const min = Number(m[1]);
-    const max = m[2] === void 0 ? min : m[3] ? Number(m[3]) : Infinity;
-    if (max < 1 || min > max) return null;
-    return { min, max, len: close - at + 1 };
+function covKindName(code) {
+  switch (code) {
+    case 0:
+      return "rule";
+    case 1:
+      return "choice-arm";
+    case 2:
+      return "dispatch-arm";
+    case 3:
+      return "label";
+  }
+}
+function covDefinitions(prog) {
+  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
+}
+function expandCompact(p) {
+  if ("code" in p) return p;
+  return ownTableProgram({
+    code: p.c,
+    k: p.k,
+    cc: p.x,
+    fx: p.e,
+    disp: p.d,
+    rules: p.r,
+    fns: p.f,
+    lines: p.l ?? 0,
+    dsp: p.p ?? [],
+    ...p.lb === void 0 ? {} : { labels: p.lb },
+    ...p.rc === void 0 ? {} : { classified: p.rc },
+    ...p.h === void 0 ? {} : { hostMode: p.h },
+    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
+    ...p.sc === void 0 ? {} : { scans: p.sc },
+    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
+    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
+    ...p.rv === void 0 ? {} : { rec: p.rv },
+    ...p.cv === void 0 ? {} : { cov: p.cv },
+    ...p.a === void 0 ? {} : { asm: p.a }
+  });
+}
+function validateDispatchSpec(spec, arity, fallbackRouted) {
+  const invalid = (arms) => {
+    for (const arm of arms) if (!Number.isInteger(arm) || arm < 0 || arm >= arity) return true;
+    return false;
   };
-  const runFrom = (ranges, negated, at) => {
-    const q2 = source[at];
-    if (q2 === "+") {
-      parts.push({ part: "run", ranges, negated, min: 1, max: Infinity });
-      return 1;
+  if (spec === void 0 || !Number.isInteger(arity) || arity < 0 || fallbackRouted !== 0 && fallbackRouted !== 1 || spec.routed.length !== arity || spec.routed.some((value) => value !== 0 && value !== 1) || invalid(spec.byKey.values()) || invalid(spec.byFold.values()) || spec.match.some((matcher) => invalid([matcher[3]]))) {
+    throw new TypeError("table: malformed dispatch");
+  }
+}
+var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
+function ownTableProgram(prog, resolved) {
+  return { ...prog, [TABLE_RUNTIME]: { resolved } };
+}
+var WIDE_CLASS_PREFIX_LO = 65535;
+var WIDE_CLASS_PREFIX_HI = 0;
+function validateClassRange(lo, hi) {
+  for (const cp of [lo, hi]) {
+    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
+      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
     }
-    if (q2 === "*") {
-      parts.push({ part: "run", ranges, negated, min: 0, max: Infinity });
-      return 1;
+  }
+  if (lo > hi) {
+    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
+  }
+}
+function encodeClassSpec(ranges) {
+  let wide = false;
+  for (const range of ranges) {
+    validateClassRange(range.lo, range.hi);
+    if (range.hi > 65535) wide = true;
+  }
+  if (!wide) {
+    let spec2 = "";
+    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
+    return spec2;
+  }
+  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
+  for (const range of ranges) {
+    spec += String.fromCharCode(
+      range.lo >>> 16,
+      range.lo & 65535,
+      range.hi >>> 16,
+      range.hi & 65535
+    );
+  }
+  return spec;
+}
+function decodeClassSpec(spec) {
+  if (spec.charCodeAt(0) === WIDE_CLASS_PREFIX_LO && spec.charCodeAt(1) === WIDE_CLASS_PREFIX_HI) {
+    if ((spec.length - 2) % 4 !== 0) throw new TypeError("table char-class spec has a truncated wide range");
+    if (spec.length === 2) throw new TypeError("table char-class spec has a wide prefix but no ranges");
+    const ranges2 = [];
+    for (let i = 2; i < spec.length; i += 4) {
+      const lo = spec.charCodeAt(i) * 65536 + spec.charCodeAt(i + 1);
+      const hi = spec.charCodeAt(i + 2) * 65536 + spec.charCodeAt(i + 3);
+      validateClassRange(lo, hi);
+      ranges2.push({ lo, hi });
     }
-    if (q2 === "?") {
-      parts.push({ part: "run", ranges, negated, min: 0, max: 1 });
-      return 1;
+    return ranges2;
+  }
+  if (spec.length % 2 !== 0) throw new TypeError("table char-class spec has an unmatched range endpoint");
+  const ranges = [];
+  for (let i = 0; i < spec.length; i += 2) {
+    const lo = spec.charCodeAt(i);
+    const hi = spec.charCodeAt(i + 1);
+    validateClassRange(lo, hi);
+    ranges.push({ lo, hi });
+  }
+  return ranges;
+}
+function resolveClass(spec) {
+  const ascii = new Uint8Array(128);
+  const hi = [];
+  for (const { lo, hi: up } of decodeClassSpec(spec)) {
+    if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1;
+    if (up >= 128) hi.push(Math.max(lo, 128), up);
+  }
+  return { ascii, hi };
+}
+function classHas(cls, code) {
+  if (code < 0) return false;
+  if (code < 128) return cls.ascii[code] === 1;
+  const hi = cls.hi;
+  for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
+  return false;
+}
+function resolveDispatch(arms, cc) {
+  const ascii = new Uint8Array(128);
+  const hi = [];
+  const open = [];
+  const armCls = [];
+  let exclusive = true;
+  let hiOwners = 0;
+  for (let a = 0; a < arms.length; a++) {
+    const ci = arms[a];
+    if (ci < 0) {
+      open.push(a);
+      armCls.push(null);
+      exclusive = false;
+      continue;
     }
-    if (q2 === "{") {
-      const b = braceQuant(at);
-      if (b) {
-        parts.push({ part: "run", ranges, negated, min: b.min, max: b.max });
-        return b.len;
-      }
+    const cls = cc[ci];
+    armCls.push(cls);
+    for (let c = 0; c < 128; c++) {
+      if (cls.ascii[c] !== 1) continue;
+      if (ascii[c] === 0) ascii[c] = a + 1;
+      else exclusive = false;
     }
-    parts.push({ part: "run", ranges, negated, min: 1, max: 1 });
-    return 0;
-  };
-  let i = 0;
-  while (i < source.length) {
-    const ch2 = source[i];
-    if (ch2 === "[") {
-      let k = i + 1;
-      const neg = source[k] === "^";
-      if (neg) k++;
-      let body = "";
-      while (k < source.length && source[k] !== "]") {
-        if (source[k] === "\\") {
-          body += source[k] + (source[k + 1] ?? "");
-          k += 2;
-        } else {
-          body += source[k];
-          k++;
-        }
-      }
-      if (source[k] !== "]") return null;
-      const ranges = parseClassRanges(body);
-      if (!ranges) return null;
-      flush();
-      i = k + 1;
-      i += runFrom(ranges, neg, i);
-      continue;
+    if (cls.hi.length > 0 && ++hiOwners > 1) exclusive = false;
+    for (let i = 0; i < cls.hi.length; i += 2) hi.push(cls.hi[i], cls.hi[i + 1], a);
+  }
+  return { ascii, hi, open, armCls, exclusive };
+}
+function buildTrivia(spec) {
+  if (spec.live !== void 0) return spec.live;
+  if (spec.plain !== void 0) return trivia(regex(new RegExp(spec.plain[0], spec.plain[1])));
+  if (spec.alts !== void 0) {
+    const [head, ...rest] = spec.alts.map(([source, flags]) => regex(new RegExp(source, flags)));
+    if (head === void 0) throw new TypeError("trivia spec has an EMPTY alternation, which matches nothing");
+    const body = rest.length === 0 ? head : choice(head, ...rest);
+    return trivia(many(body, { min: spec.min ?? 1 }));
+  }
+  const arms = {};
+  for (const [name, source, flags] of spec.arms) arms[name] = regex(new RegExp(source, flags));
+  return classifiedTrivia(arms);
+}
+function resolveTable(prog) {
+  const owner = prog[TABLE_RUNTIME];
+  const hit = owner?.resolved;
+  if (hit !== void 0) return hit;
+  const cc = prog.cc.map(resolveClass);
+  const triviaBuilt = (prog.triviaSpecs ?? []).map(buildTrivia);
+  const built = {
+    prog,
+    code: Int32Array.from(prog.code),
+    k: prog.k,
+    fns: prog.fns,
+    cc,
+    fx: prog.fx,
+    disp: prog.disp.map((d) => resolveDispatch(d, cc)),
+    trivia: triviaBuilt,
+    triviaScan: triviaBuilt.map(fastTriviaScanner),
+    triviaLabelled: triviaBuilt.map((t) => t._meta.triviaKindLabels !== void 0),
+    dsp: prog.dsp.map((d) => ({
+      byKey: new Map(d.key.map((x, i) => [x, d.keyArm[i]])),
+      byFold: new Map(d.fold.map((x, i) => [x, d.foldArm[i]])),
+      match: d.match,
+      routed: d.routed,
+      expected: d.expected
+    })),
+    rules: prog.rules
+  };
+  if (owner !== void 0) owner.resolved = built;
+  return built;
+}
+var FOLDED_RUNTIME = /* @__PURE__ */ Symbol("parseman.foldedRuntime");
+function ownFoldedProgram(base, variants) {
+  return { base, variants, [FOLDED_RUNTIME]: { byName: /* @__PURE__ */ new Map() } };
+}
+var SHARED_FIELDS = [
+  "k",
+  "cc",
+  "fx",
+  "disp",
+  "dsp",
+  "rules",
+  "labels",
+  "classified",
+  "scanSkip",
+  "scanSkipOf",
+  "scans",
+  "triviaSpecs",
+  "runtimeOnly",
+  // `rec` is a property of the GRAMMAR BUILD, not of the trackLines/hostMode
+  // axis a fold varies — every variant of one export is encoded with the same
+  // recovery setting, and a mismatch is two tables, which is what the refusal says.
+  "rec",
+  // `cov` is a property of the GRAMMAR and its coverage plan, for the same reason
+  // `rec` is a property of the build: the plan is built from the rule map, which
+  // every variant of one export shares. It ships ONCE, and a variant that
+  // disagrees is two tables — which is what the refusal says.
+  "cov"
+];
+function foldPrograms(programs, baseName) {
+  const suppliedBase = programs[baseName];
+  if (suppliedBase === void 0) throw new TypeError(`foldPrograms: no program named ${JSON.stringify(baseName)}`);
+  const base = closureArtifact(suppliedBase);
+  const variants = {};
+  for (const name of Object.keys(programs)) {
+    const p = programs[name];
+    if (p.asm !== void 0 && p.asm.length > 0) {
+      throw new TypeError(
+        `foldPrograms: program ${JSON.stringify(name)} already carries pre-compiled assemblies. An assembly is emitted from a \`code\` stream and a fold overwrites \`code\` per variant, so pre-compiling must happen AFTER the fold, per variant \u2014 not before it.`
+      );
     }
-    if (ch2 === "\\") {
-      const e = source[i + 1];
-      if (e === "d" || e === "w" || e === "s") {
-        flush();
-        i += 2;
-        i += runFrom(shorthandRanges(e), false, i);
-        continue;
-      }
-      const uni = readUnicodeEscape(source, i);
-      let cp2;
-      if (uni) {
-        cp2 = uni.cp;
-        i = uni.next;
-      } else if (e === void 0) return null;
-      else if (e in CLASS_ESCAPES) {
-        cp2 = CLASS_ESCAPES[e];
-        i += 2;
-      } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
-      else {
-        cp2 = e.codePointAt(0);
-        i += 2;
-      }
-      if (source[i] === "?") {
-        flush();
-        parts.push({ part: "lit", cps: [cp2], optional: true });
-        i++;
-      } else lit.push(cp2);
-      continue;
+    if (p.code.length !== base.code.length) {
+      throw new TypeError(
+        `foldPrograms: variant ${JSON.stringify(name)} has ${p.code.length} code words, base ${JSON.stringify(baseName)} has ${base.code.length}. A fold overwrites words; it cannot resize the stream. These are two different tables, not one table and its edits.`
+      );
     }
-    if (ch2 === "(") {
-      if (source[i + 1] !== "?" || source[i + 2] !== ":") return null;
-      let k = i + 3;
-      let depth = 1;
-      while (k < source.length && depth > 0) {
-        const c2 = source[k];
-        if (c2 === "\\") {
-          k += 2;
-          continue;
-        }
-        if (c2 === "[") {
-          let j = k + 1;
-          if (source[j] === "^") j++;
-          while (j < source.length && source[j] !== "]") {
-            if (source[j] === "\\") j += 2;
-            else j++;
-          }
-          if (source[j] !== "]") return null;
-          k = j + 1;
-          continue;
-        }
-        if (c2 === "(") depth++;
-        else if (c2 === ")") depth--;
-        k++;
-      }
-      if (depth !== 0) return null;
-      const body = source.slice(i + 3, k - 1);
-      const inner = parseScanShape(body);
-      if (!inner || !groupInnerSafe(inner)) return null;
-      const q2 = source[k];
-      if (q2 === "{") return null;
-      flush();
-      if (q2 === "+") {
-        if (shapeCanBeEmpty(inner)) return null;
-        parts.push({ part: "group", inner, min: 1, unbounded: true });
-        i = k + 1;
-      } else if (q2 === "*") {
-        if (shapeCanBeEmpty(inner)) return null;
-        parts.push({ part: "group", inner, min: 0, unbounded: true });
-        i = k + 1;
-      } else if (q2 === "?") {
-        parts.push({ part: "group", inner, min: 0, unbounded: false });
-        i = k + 1;
-      } else {
-        parts.push({ part: "group", inner, min: 1, unbounded: false });
-        i = k;
+    for (const f of SHARED_FIELDS) {
+      if (JSON.stringify(p[f]) !== JSON.stringify(base[f])) {
+        throw new TypeError(
+          `foldPrograms: variant ${JSON.stringify(name)} differs from base ${JSON.stringify(baseName)} in ${JSON.stringify(f)}, which the fold ships ONCE. Either the variants are not encodings of one grammar, or this field has become variant-dependent and needs its own delta.`
+        );
       }
-      continue;
     }
-    if (META2.has(ch2)) return null;
-    const cp = ch2.codePointAt(0);
-    i += ch2.length;
-    if (source[i] === "?") {
-      flush();
-      parts.push({ part: "lit", cps: [cp], optional: true });
-      i++;
-    } else lit.push(cp);
-  }
-  flush();
-  return parts.length ? parts : null;
-}
-function seqIsUnambiguous(parts) {
-  let hasMandatory = false;
-  for (let k = 0; k < parts.length; k++) {
-    const p = parts[k];
-    const mandatory = p.part === "lit" ? !p.optional : p.min >= 1;
-    if (mandatory) hasMandatory = true;
-    if (p.part === "group") {
-      const exposure = groupPartExposure(p);
-      if (exposure === "unsupported") {
-        const trailingOnce = k === parts.length - 1 && p.min === 1 && !p.unbounded;
-        if (!trailingOnce) return false;
-      } else if (exposure !== null) {
-        if (!firstSetsDisjoint(exposure, seqFirstAccept(parts.slice(k + 1)))) return false;
-      }
+    if (p.fns.length !== base.fns.length || p.fns.some((f, i) => f !== base.fns[i])) {
+      throw new TypeError(
+        `foldPrograms: variant ${JSON.stringify(name)} does not share the base's reducer pool BY IDENTITY. Equal source text is not enough \u2014 two closures can print alike and capture different scopes. Encode every variant from ONE grammar export.`
+      );
     }
-    const needsDisjoint = p.part === "lit" ? p.optional : p.part === "run" ? p.max > p.min : p.unbounded || p.min === 0;
-    if (needsDisjoint) {
-      const rest = seqFirstAccept(parts.slice(k + 1));
-      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false;
+    const at = [];
+    const to = [];
+    let prev = 0;
+    for (let i = 0; i < p.code.length; i++) {
+      if (p.code[i] === base.code[i]) continue;
+      at.push(i - prev);
+      to.push(p.code[i]);
+      prev = i;
     }
+    variants[name] = {
+      at,
+      to,
+      ...p.lines === void 0 ? {} : { lines: p.lines },
+      ...p.hostMode === void 0 ? {} : { hostMode: p.hostMode }
+    };
   }
-  return hasMandatory;
-}
-function rangesOverlap(a, b) {
-  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi));
-}
-function rangesSubset(sub, sup) {
-  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2));
-}
-function classSubset(t, u) {
-  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges);
-  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges);
-  if (t.negated && !u.negated) return false;
-  return rangesSubset(u.ranges, t.ranges);
-}
-function classDisjoint(t, u) {
-  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges);
-  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges);
-  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges);
-  return false;
-}
-function firstSetsDisjoint(a, b) {
-  if (a === "any" || b === "any") return false;
-  return classDisjoint(a, b);
+  return ownFoldedProgram(base, variants);
 }
-function fixedClassSeq(shape) {
-  if (shape.kind === "litFold") {
-    return shape.open.map((cp) => {
-      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp;
-      return other === cp ? { ranges: [[cp, cp]], negated: false } : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]], negated: false };
-    });
-  }
-  if (shape.kind !== "seq") return null;
-  const out = [];
-  for (const p of shape.parts) {
-    if (p.part === "lit") {
-      if (p.optional) return null;
-      for (const cp of p.cps) out.push({ ranges: [[cp, cp]], negated: false });
-    } else if (p.part === "run" && p.max === p.min && Number.isFinite(p.max)) {
-      for (let c = 0; c < p.max; c++) out.push({ ranges: p.ranges, negated: p.negated });
-    } else {
-      return null;
-    }
-  }
-  return out.length ? out : null;
-}
-function altFixedMutuallyExclusive(shape) {
-  if (shape.kind !== "alt" || shape.disjoint) return false;
-  const lists = [];
-  for (const arm of shape.arms) {
-    const f = fixedClassSeq(arm);
-    if (!f) return false;
-    lists.push(f);
+function unfoldVariant(folded, name) {
+  const byName = folded[FOLDED_RUNTIME]?.byName;
+  const hit = byName?.get(name);
+  if (hit !== void 0) return hit;
+  const d = folded.variants[name];
+  if (d === void 0) {
+    throw new TypeError(
+      `unfoldVariant: no variant ${JSON.stringify(name)}. This table carries: ${Object.keys(folded.variants).map((n) => JSON.stringify(n)).join(", ")}.`
+    );
   }
-  for (let i = 0; i < lists.length; i++) {
-    for (let j = 0; j < lists.length; j++) {
-      if (i === j) continue;
-      const a = lists[i];
-      const b = lists[j];
-      if (a.length > b.length) continue;
-      let disjointAt = false;
-      for (let p = 0; p < a.length; p++) {
-        if (classDisjoint(a[p], b[p])) {
-          disjointAt = true;
-          break;
-        }
-      }
-      if (!disjointAt) return false;
-    }
+  const base = folded.base;
+  const code = [...base.code];
+  let ip = 0;
+  for (let i = 0; i < d.at.length; i++) {
+    ip += d.at[i];
+    code[ip] = d.to[i];
   }
-  return true;
-}
-function groupPartExposure(part) {
-  const innerWiggle = trailingBacktrackClass(part.inner);
-  if (innerWiggle === "unsupported") return "unsupported";
-  const requiredOnce = !part.unbounded && part.min === 1;
-  if (requiredOnce) return innerWiggle;
-  const dropExposed = shapeFirstAccept(part.inner);
-  if (dropExposed === "any") return "unsupported";
-  if (innerWiggle === null) return dropExposed;
-  const unioned = unionCharSets([innerWiggle, dropExposed]);
-  return unioned === "any" ? "unsupported" : unioned;
+  const raw = {
+    ...base,
+    code,
+    ...d.lines === void 0 ? {} : { lines: d.lines },
+    ...d.hostMode === void 0 ? {} : { hostMode: d.hostMode }
+  };
+  const prog = ownTableProgram(raw);
+  const owner = prog[TABLE_RUNTIME];
+  owner.resolved = { ...resolveTable(base), prog, code: Int32Array.from(code) };
+  byName?.set(name, prog);
+  return prog;
 }
-function trailingBacktrackClass(shape) {
-  if (shape.kind === "chars") return { ranges: shape.ranges, negated: false };
-  if (shape.kind === "ident") return { ranges: shape.tail, negated: false };
-  if (shape.kind === "litFold") return null;
-  if (shape.kind === "seq") {
-    const last = shape.parts[shape.parts.length - 1];
-    if (last.part === "lit") {
-      return last.optional ? "unsupported" : null;
-    }
-    if (last.part === "run") {
-      if (last.max > last.min) return { ranges: last.ranges, negated: last.negated };
-      return null;
-    }
-    return groupPartExposure(last);
-  }
-  if (shape.kind === "alt") {
-    if (!shape.disjoint) return altFixedMutuallyExclusive(shape) ? null : "unsupported";
-    const classes = shape.arms.map(trailingBacktrackClass);
-    if (classes.some((c) => c === "unsupported")) return "unsupported";
-    const concrete = classes.filter((c) => c !== null);
-    if (concrete.length === 0) return null;
-    const unioned = unionCharSets(concrete);
-    return unioned === "any" ? "unsupported" : unioned;
+function expandCompactFolded(f) {
+  const variants = {};
+  for (const name of Object.keys(f.v)) {
+    const d = f.v[name];
+    variants[name] = {
+      at: d.a ?? [],
+      to: d.t ?? [],
+      ...d.l === void 0 ? {} : { lines: d.l },
+      ...d.h === void 0 ? {} : { hostMode: d.h }
+    };
   }
-  return "unsupported";
-}
-function lookaheadUnambiguous(inner, operand, negative) {
-  const tail = trailingBacktrackClass(inner);
-  if (tail === "unsupported") return false;
-  if (tail === null) return true;
-  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand);
+  return ownFoldedProgram(expandCompact(f.b), variants);
 }
-function stripTrailingLookahead(source) {
-  if (!source.endsWith(")")) return null;
-  for (const negative of [true, false]) {
-    const lead2 = negative ? "(?!" : "(?=";
-    const idx = source.lastIndexOf(lead2);
-    if (idx === -1) continue;
-    const operand = parseClassOperand(source.slice(idx + lead2.length, -1));
-    if (!operand) continue;
-    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative };
-  }
-  return null;
+
+// src/table/scan-shapes.ts
+var BACKSLASH = 92;
+var META2 = new Set("()[]{}*+?|^$.".split(""));
+function classToRanges(cls) {
+  if (cls === "\\d") return shorthandRanges("d");
+  if (cls === "\\w") return shorthandRanges("w");
+  if (cls === "\\s") return shorthandRanges("s");
+  const body = cls.slice(1, -1);
+  if (body.startsWith("^")) return null;
+  return parseClassRanges(body);
 }
-function unwrapOuterGroup(source) {
-  while (source.startsWith("(?:")) {
-    let depth = 1;
-    let i = 3;
-    let ok = true;
-    while (i < source.length && depth > 0) {
-      const ch2 = source[i];
-      if (ch2 === "\\") {
-        i += 2;
-        continue;
-      }
-      if (ch2 === "[") {
-        let j = i + 1;
-        if (source[j] === "^") j++;
-        while (j < source.length && source[j] !== "]") {
-          if (source[j] === "\\") j += 2;
-          else j++;
-        }
-        if (source[j] !== "]") {
-          ok = false;
-          break;
-        }
-        i = j + 1;
-        continue;
-      }
-      if (ch2 === "(") depth++;
-      else if (ch2 === ")") depth--;
-      i++;
+var foldEq = (cVar, cp) => {
+  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`;
+  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`;
+  return `${cVar} === ${cp}`;
+};
+function parseStringShape(source) {
+  const q2 = source[0];
+  if (q2 === void 0 || q2 === "\\" || META2.has(q2)) return null;
+  if (source.length < 3 || source[source.length - 1] !== q2) return null;
+  const inner = source.slice(1, -1);
+  const CLS = String.raw`\[\^((?:\\.|[^\]])+)\]`;
+  const ESC = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
+  let body;
+  let esc;
+  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC}\\)\\*$`).exec(inner);
+  if (m) {
+    body = m[1];
+    esc = m[2];
+  } else {
+    m = new RegExp(`^\\((?:\\?:)?${ESC}\\|${CLS}\\)\\*$`).exec(inner);
+    if (m) {
+      esc = m[1];
+      body = m[2];
     }
-    if (!ok || depth !== 0 || i !== source.length) break;
-    source = source.slice(3, -1);
   }
-  return source;
+  if (body === void 0 || esc === void 0) return null;
+  const excluded = parseClassRanges(body);
+  if (!excluded) return null;
+  const qcp = q2.codePointAt(0);
+  const inSet = (cp) => excluded.some(([lo, hi]) => cp >= lo && cp <= hi);
+  if (!inSet(qcp) || !inSet(BACKSLASH)) return null;
+  return { kind: "string", quote: qcp, excluded, escLineTerm: esc !== "." };
 }
-function splitTopLevelAlternation(source) {
-  const body = unwrapOuterGroup(source);
+function parseSeqParts(source) {
   const parts = [];
-  let depth = 0;
-  let last = 0;
-  let i = 0;
-  while (i < body.length) {
-    const ch2 = body[i];
-    if (ch2 === "\\") {
-      i += 2;
-      continue;
+  let lit = [];
+  const flush = () => {
+    if (lit.length) {
+      parts.push({ part: "lit", cps: lit, optional: false });
+      lit = [];
     }
-    if (ch2 === "[") {
-      let j = i + 1;
-      if (body[j] === "^") j++;
-      while (j < body.length && body[j] !== "]") {
-        if (body[j] === "\\") j += 2;
-        else j++;
-      }
-      if (body[j] !== "]") return null;
-      i = j + 1;
-      continue;
+  };
+  const braceQuant = (at) => {
+    const close = source.indexOf("}", at);
+    if (close === -1) return null;
+    const body = source.slice(at + 1, close);
+    const m = /^(\d+)(,(\d*)?)?$/.exec(body);
+    if (!m) return null;
+    const min = Number(m[1]);
+    const max = m[2] === void 0 ? min : m[3] ? Number(m[3]) : Infinity;
+    if (max < 1 || min > max) return null;
+    return { min, max, len: close - at + 1 };
+  };
+  const runFrom = (ranges, negated, at) => {
+    const q2 = source[at];
+    if (q2 === "+") {
+      parts.push({ part: "run", ranges, negated, min: 1, max: Infinity });
+      return 1;
     }
-    if (ch2 === "(") {
-      depth++;
-      i++;
-      continue;
+    if (q2 === "*") {
+      parts.push({ part: "run", ranges, negated, min: 0, max: Infinity });
+      return 1;
     }
-    if (ch2 === ")") {
-      depth--;
-      if (depth < 0) return null;
-      i++;
+    if (q2 === "?") {
+      parts.push({ part: "run", ranges, negated, min: 0, max: 1 });
+      return 1;
+    }
+    if (q2 === "{") {
+      const b = braceQuant(at);
+      if (b) {
+        parts.push({ part: "run", ranges, negated, min: b.min, max: b.max });
+        return b.len;
+      }
+    }
+    parts.push({ part: "run", ranges, negated, min: 1, max: 1 });
+    return 0;
+  };
+  let i = 0;
+  while (i < source.length) {
+    const ch2 = source[i];
+    if (ch2 === "[") {
+      let k = i + 1;
+      const neg = source[k] === "^";
+      if (neg) k++;
+      let body = "";
+      while (k < source.length && source[k] !== "]") {
+        if (source[k] === "\\") {
+          body += source[k] + (source[k + 1] ?? "");
+          k += 2;
+        } else {
+          body += source[k];
+          k++;
+        }
+      }
+      if (source[k] !== "]") return null;
+      const ranges = parseClassRanges(body);
+      if (!ranges) return null;
+      flush();
+      i = k + 1;
+      i += runFrom(ranges, neg, i);
       continue;
     }
-    if (ch2 === "|" && depth === 0) {
-      parts.push(body.slice(last, i));
-      last = i + 1;
-      i++;
+    if (ch2 === "\\") {
+      const e = source[i + 1];
+      if (e === "d" || e === "w" || e === "s") {
+        flush();
+        i += 2;
+        i += runFrom(shorthandRanges(e), false, i);
+        continue;
+      }
+      const uni = readUnicodeEscape(source, i);
+      let cp2;
+      if (uni) {
+        cp2 = uni.cp;
+        i = uni.next;
+      } else if (e === void 0) return null;
+      else if (e in CLASS_ESCAPES) {
+        cp2 = CLASS_ESCAPES[e];
+        i += 2;
+      } else if (e >= "a" && e <= "z" || e >= "A" && e <= "Z") return null;
+      else {
+        cp2 = e.codePointAt(0);
+        i += 2;
+      }
+      if (source[i] === "?") {
+        flush();
+        parts.push({ part: "lit", cps: [cp2], optional: true });
+        i++;
+      } else lit.push(cp2);
       continue;
     }
-    i++;
+    if (ch2 === "(") {
+      if (source[i + 1] !== "?" || source[i + 2] !== ":") return null;
+      let k = i + 3;
+      let depth = 1;
+      while (k < source.length && depth > 0) {
+        const c2 = source[k];
+        if (c2 === "\\") {
+          k += 2;
+          continue;
+        }
+        if (c2 === "[") {
+          let j = k + 1;
+          if (source[j] === "^") j++;
+          while (j < source.length && source[j] !== "]") {
+            if (source[j] === "\\") j += 2;
+            else j++;
+          }
+          if (source[j] !== "]") return null;
+          k = j + 1;
+          continue;
+        }
+        if (c2 === "(") depth++;
+        else if (c2 === ")") depth--;
+        k++;
+      }
+      if (depth !== 0) return null;
+      const body = source.slice(i + 3, k - 1);
+      const inner = parseScanShape(body);
+      if (!inner || !groupInnerSafe(inner)) return null;
+      const q2 = source[k];
+      if (q2 === "{") return null;
+      flush();
+      if (q2 === "+") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 1, unbounded: true });
+        i = k + 1;
+      } else if (q2 === "*") {
+        if (shapeCanBeEmpty(inner)) return null;
+        parts.push({ part: "group", inner, min: 0, unbounded: true });
+        i = k + 1;
+      } else if (q2 === "?") {
+        parts.push({ part: "group", inner, min: 0, unbounded: false });
+        i = k + 1;
+      } else {
+        parts.push({ part: "group", inner, min: 1, unbounded: false });
+        i = k;
+      }
+      continue;
+    }
+    if (META2.has(ch2)) return null;
+    const cp = ch2.codePointAt(0);
+    i += ch2.length;
+    if (source[i] === "?") {
+      flush();
+      parts.push({ part: "lit", cps: [cp], optional: true });
+      i++;
+    } else lit.push(cp);
   }
-  if (depth !== 0) return null;
-  parts.push(body.slice(last));
-  if (parts.length < 2 || parts.some((p) => p.length === 0)) return null;
-  return parts;
+  flush();
+  return parts.length ? parts : null;
 }
-function shapeCanBeEmpty(shape) {
-  if (shape.kind === "chars") return !shape.minOne;
-  if (shape.kind === "lookahead") return shapeCanBeEmpty(shape.inner);
-  if (shape.kind === "alt") return shape.arms.some(shapeCanBeEmpty);
-  return false;
+function seqIsUnambiguous(parts) {
+  let hasMandatory = false;
+  for (let k = 0; k < parts.length; k++) {
+    const p = parts[k];
+    const mandatory = p.part === "lit" ? !p.optional : p.min >= 1;
+    if (mandatory) hasMandatory = true;
+    if (p.part === "group") {
+      const exposure = groupPartExposure(p);
+      if (exposure === "unsupported") {
+        const trailingOnce = k === parts.length - 1 && p.min === 1 && !p.unbounded;
+        if (!trailingOnce) return false;
+      } else if (exposure !== null) {
+        if (!firstSetsDisjoint(exposure, seqFirstAccept(parts.slice(k + 1)))) return false;
+      }
+    }
+    const needsDisjoint = p.part === "lit" ? p.optional : p.part === "run" ? p.max > p.min : p.unbounded || p.min === 0;
+    if (needsDisjoint) {
+      const rest = seqFirstAccept(parts.slice(k + 1));
+      if (!firstSetsDisjoint(partFirstAccept(p), rest)) return false;
+    }
+  }
+  return hasMandatory;
 }
-function unionCharSets(sets) {
-  if (sets.some((s) => s === "any")) return "any";
-  const concrete = sets;
-  if (concrete.length === 1) return concrete[0];
-  if (concrete.some((s) => s.negated)) return "any";
-  return { ranges: concrete.flatMap((s) => s.ranges), negated: false };
+function rangesOverlap(a, b) {
+  return a.some(([lo, hi]) => b.some(([lo2, hi2]) => lo <= hi2 && lo2 <= hi));
 }
-function partFirstAccept(part) {
-  if (part.part === "lit") return { ranges: [[part.cps[0], part.cps[0]]], negated: false };
-  if (part.part === "run") return { ranges: part.ranges, negated: part.negated };
-  return shapeFirstAccept(part.inner);
+function rangesSubset(sub, sup) {
+  return sub.every(([lo, hi]) => sup.some(([lo2, hi2]) => lo >= lo2 && hi <= hi2));
 }
-function seqFirstAccept(parts) {
-  const sets = [];
-  for (const p of parts) {
-    const mandatory = p.part === "lit" ? !p.optional : p.min >= 1;
-    sets.push(partFirstAccept(p));
-    if (mandatory) break;
-  }
-  return unionCharSets(sets);
+function classSubset(t, u) {
+  if (!t.negated && !u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return false;
+  return rangesSubset(u.ranges, t.ranges);
 }
-function groupInnerSafe(shape) {
-  if (shape.kind === "chars" || shape.kind === "ident" || shape.kind === "seq" || shape.kind === "litFold") return true;
-  if (shape.kind === "lookahead") return groupInnerSafe(shape.inner);
-  if (shape.kind === "alt") return true;
+function classDisjoint(t, u) {
+  if (!t.negated && !u.negated) return !rangesOverlap(t.ranges, u.ranges);
+  if (!t.negated && u.negated) return rangesSubset(t.ranges, u.ranges);
+  if (t.negated && !u.negated) return rangesSubset(u.ranges, t.ranges);
   return false;
 }
-function shapeFirstAccept(shape) {
-  if (shapeCanBeEmpty(shape)) return "any";
-  switch (shape.kind) {
-    case "chars":
-      return { ranges: shape.ranges, negated: false };
-    case "ident":
-      return { ranges: shape.head, negated: false };
-    case "until":
-      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
-    case "delimited":
-      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
-    case "string":
-      return { ranges: [[shape.quote, shape.quote]], negated: false };
-    case "litFold": {
-      const cp = shape.open[0];
-      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false };
-      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false };
-      return { ranges: [[cp, cp]], negated: false };
-    }
-    case "seq":
-      return seqFirstAccept(shape.parts);
-    case "lookahead":
-      return shapeFirstAccept(shape.inner);
-    // zero-width — doesn't change first-char acceptance
-    case "alt": {
-      const sets = shape.firsts.map((f) => f === null ? "any" : f);
-      return unionCharSets(sets);
-    }
-  }
+function firstSetsDisjoint(a, b) {
+  if (a === "any" || b === "any") return false;
+  return classDisjoint(a, b);
 }
-function allPairsDisjoint(sets) {
-  for (let i = 0; i < sets.length; i++) {
-    const a = sets[i];
-    if (a === "any") return false;
-    for (let j = i + 1; j < sets.length; j++) {
-      const b = sets[j];
-      if (b === "any" || !classDisjoint(a, b)) return false;
+function fixedClassSeq(shape) {
+  if (shape.kind === "litFold") {
+    return shape.open.map((cp) => {
+      const other = cp >= 65 && cp <= 90 ? cp + 32 : cp >= 97 && cp <= 122 ? cp - 32 : cp;
+      return other === cp ? { ranges: [[cp, cp]], negated: false } : { ranges: [[Math.min(cp, other), Math.min(cp, other)], [Math.max(cp, other), Math.max(cp, other)]], negated: false };
+    });
+  }
+  if (shape.kind !== "seq") return null;
+  const out = [];
+  for (const p of shape.parts) {
+    if (p.part === "lit") {
+      if (p.optional) return null;
+      for (const cp of p.cps) out.push({ ranges: [[cp, cp]], negated: false });
+    } else if (p.part === "run" && p.max === p.min && Number.isFinite(p.max)) {
+      for (let c = 0; c < p.max; c++) out.push({ ranges: p.ranges, negated: p.negated });
+    } else {
+      return null;
     }
   }
-  return true;
+  return out.length ? out : null;
 }
-function parseAlternation(source) {
+function altFixedMutuallyExclusive(shape) {
+  if (shape.kind !== "alt" || shape.disjoint) return false;
+  const lists = [];
+  for (const arm of shape.arms) {
+    const f = fixedClassSeq(arm);
+    if (!f) return false;
+    lists.push(f);
+  }
+  for (let i = 0; i < lists.length; i++) {
+    for (let j = 0; j < lists.length; j++) {
+      if (i === j) continue;
+      const a = lists[i];
+      const b = lists[j];
+      if (a.length > b.length) continue;
+      let disjointAt = false;
+      for (let p = 0; p < a.length; p++) {
+        if (classDisjoint(a[p], b[p])) {
+          disjointAt = true;
+          break;
+        }
+      }
+      if (!disjointAt) return false;
+    }
+  }
+  return true;
+}
+function groupPartExposure(part) {
+  const innerWiggle = trailingBacktrackClass(part.inner);
+  if (innerWiggle === "unsupported") return "unsupported";
+  const requiredOnce = !part.unbounded && part.min === 1;
+  if (requiredOnce) return innerWiggle;
+  const dropExposed = shapeFirstAccept(part.inner);
+  if (dropExposed === "any") return "unsupported";
+  if (innerWiggle === null) return dropExposed;
+  const unioned = unionCharSets([innerWiggle, dropExposed]);
+  return unioned === "any" ? "unsupported" : unioned;
+}
+function trailingBacktrackClass(shape) {
+  if (shape.kind === "chars") return { ranges: shape.ranges, negated: false };
+  if (shape.kind === "ident") return { ranges: shape.tail, negated: false };
+  if (shape.kind === "litFold") return null;
+  if (shape.kind === "seq") {
+    const last = shape.parts[shape.parts.length - 1];
+    if (last.part === "lit") {
+      return last.optional ? "unsupported" : null;
+    }
+    if (last.part === "run") {
+      if (last.max > last.min) return { ranges: last.ranges, negated: last.negated };
+      return null;
+    }
+    return groupPartExposure(last);
+  }
+  if (shape.kind === "alt") {
+    if (!shape.disjoint) return altFixedMutuallyExclusive(shape) ? null : "unsupported";
+    const classes = shape.arms.map(trailingBacktrackClass);
+    if (classes.some((c) => c === "unsupported")) return "unsupported";
+    const concrete = classes.filter((c) => c !== null);
+    if (concrete.length === 0) return null;
+    const unioned = unionCharSets(concrete);
+    return unioned === "any" ? "unsupported" : unioned;
+  }
+  return "unsupported";
+}
+function lookaheadUnambiguous(inner, operand, negative) {
+  const tail = trailingBacktrackClass(inner);
+  if (tail === "unsupported") return false;
+  if (tail === null) return true;
+  return negative ? classSubset(tail, operand) : classDisjoint(tail, operand);
+}
+function stripTrailingLookahead(source) {
+  if (!source.endsWith(")")) return null;
+  for (const negative of [true, false]) {
+    const lead2 = negative ? "(?!" : "(?=";
+    const idx = source.lastIndexOf(lead2);
+    if (idx === -1) continue;
+    const operand = parseClassOperand(source.slice(idx + lead2.length, -1));
+    if (!operand) continue;
+    return { base: source.slice(0, idx), ranges: operand.ranges, classNegated: operand.negated, negative };
+  }
+  return null;
+}
+function unwrapOuterGroup(source) {
+  while (source.startsWith("(?:")) {
+    let depth = 1;
+    let i = 3;
+    let ok = true;
+    while (i < source.length && depth > 0) {
+      const ch2 = source[i];
+      if (ch2 === "\\") {
+        i += 2;
+        continue;
+      }
+      if (ch2 === "[") {
+        let j = i + 1;
+        if (source[j] === "^") j++;
+        while (j < source.length && source[j] !== "]") {
+          if (source[j] === "\\") j += 2;
+          else j++;
+        }
+        if (source[j] !== "]") {
+          ok = false;
+          break;
+        }
+        i = j + 1;
+        continue;
+      }
+      if (ch2 === "(") depth++;
+      else if (ch2 === ")") depth--;
+      i++;
+    }
+    if (!ok || depth !== 0 || i !== source.length) break;
+    source = source.slice(3, -1);
+  }
+  return source;
+}
+function splitTopLevelAlternation(source) {
+  const body = unwrapOuterGroup(source);
+  const parts = [];
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch2 = body[i];
+    if (ch2 === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch2 === "[") {
+      let j = i + 1;
+      if (body[j] === "^") j++;
+      while (j < body.length && body[j] !== "]") {
+        if (body[j] === "\\") j += 2;
+        else j++;
+      }
+      if (body[j] !== "]") return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch2 === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch2 === ")") {
+      depth--;
+      if (depth < 0) return null;
+      i++;
+      continue;
+    }
+    if (ch2 === "|" && depth === 0) {
+      parts.push(body.slice(last, i));
+      last = i + 1;
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (depth !== 0) return null;
+  parts.push(body.slice(last));
+  if (parts.length < 2 || parts.some((p) => p.length === 0)) return null;
+  return parts;
+}
+function shapeCanBeEmpty(shape) {
+  if (shape.kind === "chars") return !shape.minOne;
+  if (shape.kind === "lookahead") return shapeCanBeEmpty(shape.inner);
+  if (shape.kind === "alt") return shape.arms.some(shapeCanBeEmpty);
+  return false;
+}
+function unionCharSets(sets) {
+  if (sets.some((s) => s === "any")) return "any";
+  const concrete = sets;
+  if (concrete.length === 1) return concrete[0];
+  if (concrete.some((s) => s.negated)) return "any";
+  return { ranges: concrete.flatMap((s) => s.ranges), negated: false };
+}
+function partFirstAccept(part) {
+  if (part.part === "lit") return { ranges: [[part.cps[0], part.cps[0]]], negated: false };
+  if (part.part === "run") return { ranges: part.ranges, negated: part.negated };
+  return shapeFirstAccept(part.inner);
+}
+function seqFirstAccept(parts) {
+  const sets = [];
+  for (const p of parts) {
+    const mandatory = p.part === "lit" ? !p.optional : p.min >= 1;
+    sets.push(partFirstAccept(p));
+    if (mandatory) break;
+  }
+  return unionCharSets(sets);
+}
+function groupInnerSafe(shape) {
+  if (shape.kind === "chars" || shape.kind === "ident" || shape.kind === "seq" || shape.kind === "litFold") return true;
+  if (shape.kind === "lookahead") return groupInnerSafe(shape.inner);
+  if (shape.kind === "alt") return true;
+  return false;
+}
+function shapeFirstAccept(shape) {
+  if (shapeCanBeEmpty(shape)) return "any";
+  switch (shape.kind) {
+    case "chars":
+      return { ranges: shape.ranges, negated: false };
+    case "ident":
+      return { ranges: shape.head, negated: false };
+    case "until":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "delimited":
+      return { ranges: [[shape.open[0], shape.open[0]]], negated: false };
+    case "string":
+      return { ranges: [[shape.quote, shape.quote]], negated: false };
+    case "litFold": {
+      const cp = shape.open[0];
+      if (cp >= 65 && cp <= 90) return { ranges: [[cp, cp], [cp + 32, cp + 32]], negated: false };
+      if (cp >= 97 && cp <= 122) return { ranges: [[cp, cp], [cp - 32, cp - 32]], negated: false };
+      return { ranges: [[cp, cp]], negated: false };
+    }
+    case "seq":
+      return seqFirstAccept(shape.parts);
+    case "lookahead":
+      return shapeFirstAccept(shape.inner);
+    // zero-width — doesn't change first-char acceptance
+    case "alt": {
+      const sets = shape.firsts.map((f) => f === null ? "any" : f);
+      return unionCharSets(sets);
+    }
+  }
+}
+function allPairsDisjoint(sets) {
+  for (let i = 0; i < sets.length; i++) {
+    const a = sets[i];
+    if (a === "any") return false;
+    for (let j = i + 1; j < sets.length; j++) {
+      const b = sets[j];
+      if (b === "any" || !classDisjoint(a, b)) return false;
+    }
+  }
+  return true;
+}
+function parseAlternation(source) {
   const parts = splitTopLevelAlternation(source);
   if (!parts) return null;
   const arms = [];
@@ -4662,6 +5038,7 @@ function childSlots(code, ip, out) {
     case OP_GATE:
     case OP_SCOPE:
     case OP_SCOPE_CAP:
+    case OP_SCOPE_PLAIN:
     case OP_WITHCTX:
     case OP_XFORM:
     case OP_NODE:
@@ -4750,7 +5127,7 @@ function reachableSites(code, roots) {
 }
 function transfer(code, ip, at, hostCst) {
   const op = code[ip];
-  if (op === OP_SCOPE || op === OP_SCOPE_CAP) {
+  if (op === OP_SCOPE || op === OP_SCOPE_CAP || op === OP_SCOPE_PLAIN) {
     const ki = code[ip + 1];
     const tri = ki < 0 ? TRI_NONE : ki;
     const cap = op === OP_SCOPE_CAP ? CAP_ON : at.cap;
@@ -4831,6 +5208,7 @@ var EMITTED_PARAMS = [
   "pushCstLeaf",
   "pushCstChild",
   "rollbackTriviaAt",
+  "rollbackScannedTriviaAt",
   "failAt",
   "classHas",
   "consumeTrivia",
@@ -4974,19 +5352,24 @@ if(ctx._errors!==undefined&&ctx._errors.length!==${t}er)ctx._errors.length=${t}e
   if (!s.fd && !s.er) return `if(${t}n)rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,0,undefined,${t}lg,${t}rt)`;
   return `if(${t}n){rollbackTriviaAt(ctx,${t}raw,${t}tl,${t}lv,${s.fd ? `${t}fd` : "0"},${s.er ? `${t}er` : "undefined"},${t}lg,${t}rt)}`;
 }
-function emitTerm(callee, dst, t, l, skip, s) {
+function emitTerm(callee, dst, t, l, skip) {
   const fast = `const ${t}v=${callee}(input,cur,ctx)
 if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
 cur=EC.e`;
   if (l.tri === TRI_NONE) return fast;
-  const scanned = `${emitMark(t, l.buf, s)}
+  const scanned = `const ${t}tl=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const ${t}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const ${t}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
 const ${t}s=${skip}(input,cur,ctx)
+const ${t}stl=ctx._cstBuf!==undefined?(ctx._cstBuf.tl!==undefined?ctx._cstBuf.tl.length:0):(ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0)
+const ${t}slg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+const ${t}srt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0
 const ${t}v=${callee}(input,${t}s,ctx)
 if(${t}v===FAIL)return FAIL
 ${dst}=${t}v
 if(EC.e>${t}s)cur=EC.e
-else{${emitRollback(t, l.buf, s)}}`;
+else{rollbackScannedTriviaAt(ctx,${t}tl,${t}stl,${t}lg,${t}slg,${t}rt,${t}srt)}`;
   if (l.tri !== TRI_UNKNOWN) return scanned;
   return `if(ctx.trivia===undefined){
 ${fast}
@@ -5149,7 +5532,7 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
     const op = code[ip];
     if (op === OP_GATE && (cfg.tolerant || cfg.probe)) return code[ip + 2];
     if (op === OP_RULE) return code[ip + 1];
-    if (op === OP_SCOPE && code[ip + 3] === 0 && code[ip + 1] >= 0 && labels.at(ip).tri === code[ip + 1]) {
+    if ((op === OP_SCOPE_PLAIN || op === OP_SCOPE && code[ip + 3] === 0) && code[ip + 1] >= 0 && labels.at(ip).tri === code[ip + 1]) {
       return code[ip + 2];
     }
     return void 0;
@@ -5200,1048 +5583,731 @@ ${cfg.probe ? `failAt(ctx,${xf},pos)
             tests.push(`input.charCodeAt(${at})===${f}`);
           }
         }
-        return `${head}
-${reads.length > 0 ? `${reads.join("\n")}
-` : ""}if(${tests.join("&&")}){
-const e=pos+${s.length}
-const v=input.slice(pos,e)
-${captureLeaf("v")}
-${track ? "_trackLines(ctx,input,e)\n" : ""}EC.e=e
-return v
-}
-ctx._fe=pos;ctx._fx=${xf}
-${cfg.probe ? `failAt(ctx,${xf},pos)
-` : ""}return FAIL
-}`;
-      }
-      case OP_RX:
-      case OP_RX_TRACK: {
-        const xf = fxRef(code[ip + 2]);
-        const track = op === OP_RX_TRACK;
-        const scanned = emitScan(code[ip + 1], xf, track, captureLeaf);
-        if (scanned !== void 0) return `${head}${scanned}}`;
-        const rxk = k[code[ip + 1]];
-        if (!(rxk instanceof RegExp) || !rxk.sticky) throw new Unemittable("a non-sticky regex row");
-        const re = kRef(code[ip + 1]);
-        return `${head}
-${re}.lastIndex=pos
-if(${re}.test(input)){
-const e=${re}.lastIndex
-const v=input.slice(pos,e)
-${captureLeaf("v")}
-${track ? "_trackLines(ctx,input,e)\n" : ""}EC.e=e
-return v
-}
-ctx._fe=pos;ctx._fx=${xf}
-${cfg.probe ? `failAt(ctx,${xf},pos)
-` : ""}return FAIL
-}`;
-      }
-      case OP_EMPTY:
-        return `${head}EC.e=pos;return ''}`;
-      case OP_GATE: {
-        const child = link(code[ip + 2]);
-        const ci = classes.push([t.cc[code[ip + 1]]]) - 1;
-        classPlan.push([code[ip + 1]]);
-        const cls = hoist("cl", `CLS[${ci}][0]`);
-        const xf = fxRef(code[ip + 3]);
-        return `${head}
-if(!classHas(${cls},lead(input,pos))){ctx._fe=pos;ctx._fx=${xf};return FAIL}
-return ${child}(input,pos,ctx)
-}`;
-      }
-      case OP_XFORM: {
-        const fn = fnRef(code[ip + 1]);
-        const child = link(code[ip + 2]);
-        return `${head}
-const v=${child}(input,pos,ctx)
-if(v===FAIL)return FAIL
-return ${fn}(v,{start:pos,end:EC.e})
-}`;
-      }
-      case OP_LABEL: {
-        const child = link(code[ip + 1]);
-        const xf = fxRef(code[ip + 2]);
-        return `${head}
-const v=${child}(input,pos,ctx)
-if(v===FAIL)ctx._fx=${xf}
-return v
-}`;
-      }
-      case OP_FIELD: {
-        const name = q(k[code[ip + 1]]);
-        const child = link(code[ip + 2]);
-        return `${head}
-const v=${child}(input,pos,ctx)
-if(v===FAIL)return FAIL
-const f=ctx._fields
-if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
-return v
-}`;
-      }
-      case OP_EXPECT: {
-        const child = link(code[ip + 1]);
-        const xf = fxRef(code[ip + 2]);
-        return `${head}
-const v=${child}(input,pos,ctx)
-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
-EC.e=pos
-return err
-}`;
-      }
-      case OP_ROUTED: {
-        const fb = code[ip + 1];
-        const fallback = fb >= 0 ? link(fb) : void 0;
-        const push = `pushCstLeaf(ctx,{_tag:'leaf',value:it.value,span:it.span})`;
-        return `${head}
-const it=ctx._routed
-if(it===undefined||pos!==it.span.start){
-${fallback !== void 0 ? `return ${fallback}(input,pos,ctx)` : "ctx._fe=pos;ctx._fx=ROUTED_FX;return FAIL"}
-}
-${L.buf ? push : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${push}`}
-EC.e=it.span.end
-return it.value
-}`;
-      }
-      case OP_SCAN: {
-        const si = code[ip + 1];
-        return `${head}
-const r=SCANS[${si}].parse(input,pos,ctx)
-if(!r.ok){ctx._fe=r.span.start;ctx._fx=r.expected??EMPTY_FX;return FAIL}
-EC.e=r.span.end
-return r.value
-}`;
-      }
-      case OP_SCOPE:
-      case OP_SCOPE_CAP: {
-        const ki = code[ip + 1];
-        const cap = op === OP_SCOPE_CAP;
-        const flags = code[ip + 3];
-        const child = link(code[ip + 2]);
-        const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
-        const tri = ki < 0 ? "undefined" : hoist("tv", `TRIVIA[${ki}]`);
-        const lab = ki < 0 ? "undefined" : hoist("tl", `TRIVIA[${ki}]._meta.triviaKindLabels`);
-        const strict = (flags & 2) !== 0 ? "refuseUnclassifiedRootScope(ctx._rootTriviaStrictScopes)\n" : "";
-        const rootCap = (flags & 1) !== 0;
-        return `${head}
-${strict}${rootCap ? "const sR=ctx._rootTriviaCapture\nctx._rootTriviaCapture=false\n" : ""}const sT=ctx.trivia,sL=ctx.triviaKindLabels,sS=_pfScan${cap ? ",sC=ctx.captureTrivia" : ""}
-_pfScan=${scanFor}
-ctx.trivia=${tri}
-ctx.triviaKindLabels=${lab}
-${cap ? "ctx.captureTrivia=true\n" : ""}const v=${child}(input,pos,ctx)
-${cap ? "ctx.captureTrivia=sC\n" : ""}ctx.trivia=sT
-ctx.triviaKindLabels=sL
-_pfScan=sS
-${rootCap ? "ctx._rootTriviaCapture=sR\n" : ""}return v
-}`;
-      }
-      /* ── boundaries ──────────────────────────────────────────────────────── */
-      case OP_TOKEN:
-      case OP_LEAF: {
-        const isToken = op === OP_TOKEN;
-        const fn = isToken ? void 0 : fnRef(code[ip + 1]);
-        const child = link(isToken ? code[ip + 1] : code[ip + 2]);
-        const wasCap = L.buf ? "true" : "(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)";
-        return `${head}
-const sBuf=ctx._cstBuf,sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
-const sOtl=ctx._triviaLog
-${isToken ? "const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan,sRtl=ctx._rootTriviaLog\n" : ""}const wasCap=${wasCap}
-${isToken ? `_pfScan=null
-ctx.trivia=undefined
-ctx.triviaKindLabels=undefined
-` : ""}ctx._cstBuf=undefined
-ctx._cstChildren=undefined
-ctx._cstLeaves=undefined
-ctx._cstRawChildren=undefined
-ctx._cstTriviaLog=undefined
-ctx._triviaLog=undefined
-${isToken ? "ctx._rootTriviaLog=undefined\n" : ""}let v
-try{v=${child}(input,pos,ctx)}finally{
-${isToken ? `_pfScan=sScan
-ctx.trivia=sTri
-ctx.triviaKindLabels=sKinds
-ctx._rootTriviaLog=sRtl
-` : ""}ctx._cstBuf=sBuf
-ctx._cstChildren=sCh
-ctx._cstLeaves=sLv
-ctx._cstRawChildren=sRaw
-ctx._cstTriviaLog=sTl
-ctx._triviaLog=sOtl
-}
-if(v===FAIL)return FAIL
-const e=EC.e
-const out=${isToken ? "input.slice(pos,e)" : `${fn}(v,{start:pos,end:e})`}
-if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:out,span:{start:pos,end:e}})
-EC.e=e
-return out
-}`;
-      }
-      /* ── transaction ─────────────────────────────────────────────────────── */
-      case OP_ATTEMPT: {
-        const child = link(code[ip + 1]);
-        const p = tmp();
-        return `${head}
-${emitMark(p, L.buf, sinks)}
-const v=${child}(input,pos,ctx)
-if(v!==FAIL)return v
-${emitRollback(p, L.buf, sinks)}
-if(ctx._fc===true)return FAIL
-ctx._fe=pos
-return FAIL
-}`;
-      }
-      case OP_NOT: {
-        const child = link(code[ip + 1]);
-        const xf = fxRef(code[ip + 2]);
-        const p = tmp();
-        return `${head}
-${emitMark(p, L.buf, sinks)}
-const v=${child}(input,pos,ctx)
-${emitRollback(p, L.buf, sinks)}
-if(v===FAIL){EC.e=pos;return null}
-ctx._fe=pos
-ctx._fx=${xf}
-return FAIL
-}`;
-      }
-      case OP_PEEK: {
-        const child = link(code[ip + 1]);
-        const xf = fxRef(code[ip + 2]);
-        const p = tmp();
-        return `${head}
-${emitMark(p, L.buf, sinks)}
-const v=${child}(input,pos,ctx)
-${emitRollback(p, L.buf, sinks)}
-if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
-EC.e=pos
-return null
-}`;
-      }
-      case OP_OPT: {
-        const child = link(code[ip + 1]);
-        const p = tmp();
-        return `${head}
-${emitMark(p, L.buf, sinks)}
-ctx._fc=false
-const v=${child}(input,pos,ctx)
-if(v===FAIL){
-if(ctx._fc===true)return FAIL
-${emitRollback(p, L.buf, sinks)}
-EC.e=pos
-return null
-}
-return v
-}`;
-      }
-      case OP_SEQ:
-      case OP_SEQV:
-      case OP_SEQX: {
-        const fused = op === OP_SEQX;
-        const base = fused ? ip + 3 : ip + 2;
-        const n = code[fused ? ip + 2 : ip + 1];
-        const wantValues = op !== OP_SEQV;
-        for (let i = 1; i < n; i++) {
-          if (code[code[base + i]] === OP_ADJ) {
-            throw new Unemittable("a sequence carrying an adjacency assertion (OP_ADJ)");
-          }
-        }
-        const fn = fused ? fnRef(code[ip + 1]) : void 0;
-        const kids = [];
-        for (let i = 0; i < n; i++) kids.push(link(code[base + i]));
-        const sy = REC ? `${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));
-        parts.push(`const v0=${kids[0]}(input,pos,ctx)`, "if(v0===FAIL)return FAIL");
-        const close = () => REC ? `${parts.join("\n")}
-}finally{ctx._sync=${sy}}
-}` : `${parts.join("\n")}
-}`;
-        if (n === 1) {
-          parts.push(fused ? `return ${fn}([v0],{start:pos,end:EC.e})` : wantValues ? "return [v0]" : "return undefined");
-          return close();
-        }
-        parts.push("let cur=EC.e");
-        const names = ["v0"];
-        for (let i = 1; i < n; i++) {
-          const vn = `v${i}`;
-          parts.push(`let ${vn}`);
-          if (REC) parts.push(pub(i));
-          parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L), sinks));
-          names.push(vn);
-        }
-        parts.push("EC.e=cur");
-        parts.push(fused ? `return ${fn}([${names.join(",")}],{start:pos,end:cur})` : wantValues ? `return [${names.join(",")}]` : "return undefined");
-        return close();
-      }
-      case OP_CHOICE: {
-        const table = disp[code[ip + 1]];
-        const n = code[ip + 2];
-        const choiceFx = fxRef(code[ip + 3]);
-        const base = ip + 4;
-        const arms = [];
-        for (let i = 0; i < n; i++) arms.push(link(code[base + i]));
-        const axi = armExpected.push(
-          Array.from({ length: n }, (_, i) => t.fx[code[base + n + i]])
-        ) - 1;
-        armExpectedPlan.push(Array.from({ length: n }, (_, i) => code[base + n + i]));
-        const afx = hoist("afx", `AFX[${axi}]`);
-        if (table.exclusive) {
-          const di = code[ip + 1];
-          const asc = hoist("as", `DISP[${di}].ascii`);
-          const hiArr = table.hi;
-          const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join("\n");
-          return `${head}
-const c=lead(input,pos)
-let arm=-1
-if(c>=0&&c<128){const a=${asc}[c];if(a!==0)arm=a-1}
-${hiArr.length === 0 ? "" : `else if(c>=128){const h=${hoist("hi", `DISP[${di}].hi`)}
-for(let i=0;i<h.length;i+=3){if(c>=h[i]&&c<=h[i+1]){arm=h[i+2];break}}}`}
-if(arm>=0){
-ctx._fc=false
-let v
-switch(arm){
-${armSwitch}
-}
-if(v!==FAIL)return v
-if(ctx._fc===true)return FAIL
-const af=ctx._fx
-if(af!==undefined&&af.length>0){ctx._fe=pos;return FAIL}
-}
-ctx._fe=pos;ctx._fx=${choiceFx}
-return FAIL
-}`;
-        }
-        const ci = classes.push(Array.from({ length: n }, (_, i) => table.armCls[i] ?? null)) - 1;
-        classPlan.push(Array.from({ length: n }, (_, i) => prog.disp[code[ip + 1]][i] ?? -1));
-        const gates = classes[ci];
-        const gRef = hoist("g", `CLS[${ci}]`);
-        const maskable = n <= 32;
-        let maskName = "";
-        if (maskable) {
-          maskName = hoist("mk", `MASK[${masks.push(maskForClassRow(gates)) - 1}]`);
-          maskPlan.push(ci);
-        }
-        const p = tmp();
-        const maskArms = arms.map((a, i) => `
-if((bits&${1 << i})!==0){
-ctx._fc=false
-{const v=${a}(input,pos,ctx)
-if(v!==FAIL)return v}
-for(let j=prev;j<${i};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
-prev=${i + 1}
-acc=_accSet(ctx._fx,acc)
-if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
-${emitRollback(p, L.buf, sinks)}
-}`).join("");
-        const generalArms = arms.map((a, i) => `
-if(${gRef}[${i}]===null||classHas(${gRef}[${i}],c)){
-ctx._fc=false
-{const v=${a}(input,pos,ctx)
-if(v!==FAIL)return v}
-acc=_accSet(ctx._fx,acc)
-if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
-${emitRollback(p, L.buf, sinks)}
-}else acc=_accSet(${afx}[${i}],acc)`).join("");
-        return `${head}
-const c=lead(input,pos)
-${emitMark(p, L.buf, sinks)}
-let acc
-${maskable ? `if(c<128){
-const bits=${maskName}[c<0?128:c]
-let prev=0
-${maskArms}
-for(let j=prev;j<${n};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
-ctx._fe=pos;ctx._fx=acc??${choiceFx}
-return FAIL
+        return `${head}
+${reads.length > 0 ? `${reads.join("\n")}
+` : ""}if(${tests.join("&&")}){
+const e=pos+${s.length}
+const v=input.slice(pos,e)
+${captureLeaf("v")}
+${track ? "_trackLines(ctx,input,e)\n" : ""}EC.e=e
+return v
 }
-` : ""}${generalArms}
-ctx._fe=pos;ctx._fx=acc??${choiceFx}
-return FAIL
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)
+` : ""}return FAIL
 }`;
       }
-      case OP_DISPATCH: {
-        const di = code[ip + 2];
-        const spec = dsp[di];
-        const selector = link(code[ip + 1]);
-        const otherIp = code[ip + 3];
-        const other = otherIp >= 0 ? link(otherIp) : void 0;
-        const otherRouted = code[ip + 4] === 1;
-        const n = code[ip + 5];
-        const armBase = ip + 6;
-        const arms = [];
-        for (let i = 0; i < n; i++) arms.push(link(code[armBase + i]));
-        const bk = hoist("bk", `DSP[${di}].byKey`);
-        const rt = hoist("rt", `DSP[${di}].routed`);
-        const dx = hoist("dx", `DSP[${di}].expected`);
-        const claims = (m) => {
-          switch (m[0]) {
-            case 0:
-              return `key.startsWith(${q(m[1])})`;
-            case 1:
-              return `key.endsWith(${q(m[1])})`;
-            case 3:
-              return `asciiFoldKey(key).startsWith(${q(m[1])})`;
-            case 4:
-              return `asciiFoldKey(key).endsWith(${q(m[1])})`;
-            default:
-              return `new RegExp(${q(m[1])},${q(m[2])}).test(key)`;
-          }
-        };
-        const chain = spec.match.length === 0 ? "" : `if(arm===undefined){
-${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${claims(m)})arm=${m[3]}`).join("\n")}
-}
-`;
-        const fold = spec.byFold.size > 0 ? `if(arm===undefined)arm=${hoist("bf", `DSP[${di}].byFold`)}.get(asciiFoldKey(key))
-` : "";
-        const m1 = tmp();
-        const m2 = tmp();
+      case OP_RX:
+      case OP_RX_TRACK: {
+        const xf = fxRef(code[ip + 2]);
+        const track = op === OP_RX_TRACK;
+        const scanned = emitScan(code[ip + 1], xf, track, captureLeaf);
+        if (scanned !== void 0) return `${head}${scanned}}`;
+        const rxk = k[code[ip + 1]];
+        if (!(rxk instanceof RegExp) || !rxk.sticky) throw new Unemittable("a non-sticky regex row");
+        const re = kRef(code[ip + 1]);
         return `${head}
-${emitMark(m1, L.buf, sinks)}
-const sv=${selector}(input,pos,ctx)
-if(sv===FAIL)return FAIL
-const selEnd=EC.e
-const key=sv
-let arm=${bk}.get(key)
-${fold}${chain}let ur
-if(arm===undefined){
-${other === void 0 ? `ctx._fe=selEnd;ctx._fx=${dx};return FAIL` : `ur=${String(otherRouted)}`}
-}else ur=${rt}[arm]===1
-const savedRouted=ctx._routed
-${emitMark(m2, L.buf, sinks)}
-if(ur){
-${emitRollback(m1, L.buf, sinks)}
-${emitMark(m2, L.buf, sinks, false)}
-ctx._routed={value:key,span:{start:pos,end:selEnd}}
-}
-const at=ur?pos:selEnd
-let v
-switch(arm){
-${arms.map((a, i) => `case ${i}:v=${a}(input,at,ctx);break`).join("\n")}
-${other === void 0 ? "" : `default:v=${other}(input,at,ctx)`}
-}
-if(ur)ctx._routed=savedRouted
-if(v===FAIL){
-${emitRollback(m2, L.buf, sinks)}
-ctx._fc=true
-return FAIL
+${re}.lastIndex=pos
+if(${re}.test(input)){
+const e=${re}.lastIndex
+const v=input.slice(pos,e)
+${captureLeaf("v")}
+${track ? "_trackLines(ctx,input,e)\n" : ""}EC.e=e
+return v
 }
-return [key,v]
+ctx._fe=pos;ctx._fx=${xf}
+${cfg.probe ? `failAt(ctx,${xf},pos)
+` : ""}return FAIL
 }`;
       }
-      case OP_REP:
-      case OP_REPV: {
+      case OP_EMPTY:
+        return `${head}EC.e=pos;return ''}`;
+      case OP_GATE: {
+        const child = link(code[ip + 2]);
+        const ci = classes.push([t.cc[code[ip + 1]]]) - 1;
+        classPlan.push([code[ip + 1]]);
+        const cls = hoist("cl", `CLS[${ci}][0]`);
+        const xf = fxRef(code[ip + 3]);
+        return `${head}
+if(!classHas(${cls},lead(input,pos))){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+return ${child}(input,pos,ctx)
+}`;
+      }
+      case OP_XFORM: {
+        const fn = fnRef(code[ip + 1]);
+        const child = link(code[ip + 2]);
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+return ${fn}(v,{start:pos,end:EC.e})
+}`;
+      }
+      case OP_LABEL: {
         const child = link(code[ip + 1]);
-        const min = code[ip + 2];
-        const max = code[ip + 3];
-        const sepIp = code[ip + 4];
-        const sep = sepIp >= 0 ? link(sepIp) : void 0;
-        const flags = code[ip + 5];
-        const keepSeparators = (flags & 2) !== 0;
-        const trailingAllowed = (flags & 1) !== 0;
-        const reportItem = (flags & 4) !== 0;
-        const itemFx = reportItem ? fxRef(code[ip + 6]) : "EMPTY_FX";
-        const collect = op === OP_REP;
-        const skipBeforeFirst = sepIp < 0 && min === 0;
-        const p = tmp();
-        const via = sep !== void 0 ? "false" : min === 0 ? skipBeforeFirst ? "true" : "count>0" : `count>=${min}&&count>0`;
-        const leadTrivia = skipBeforeFirst ? "true" : "count>0";
-        const skip = skipFor(L);
-        const knownTrivia = L.tri === TRI_NONE ? false : L.tri !== TRI_UNKNOWN ? true : void 0;
-        const hasTrivia = knownTrivia === void 0 ? "hasTrivia" : String(knownTrivia);
-        const needMark = L.buf ? "true" : "needMark";
-        const pfd = sinks.fd ? `${p}fd` : "0";
-        const per = sinks.er ? `${p}er` : "undefined";
-        const rb = L.buf ? `_rbBuf(ctx,${p}raw,${p}tl,${p}lv,${p}lg,${p}rt)${sinks.fd ? `
-if(ctx._fields!==undefined&&ctx._fields.length!==${p}fd)ctx._fields.length=${p}fd` : ""}${sinks.er ? `
-if(ctx._errors!==undefined&&ctx._errors.length!==${p}er)ctx._errors.length=${p}er` : ""}` : `if(needMark)rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)`;
-        const markSinks = `${sinks.fd ? `
-${p}fd=ctx._fields!==undefined?ctx._fields.length:0` : ""}${sinks.er ? `
-${p}er=ctx._errors!==undefined?ctx._errors.length:0` : ""}`;
-        const markBody = L.buf ? `const b=ctx._cstBuf
-const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
-const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
-const l=b.tl;${p}tl=l!==undefined?l.length:0
-${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
-${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}` : `if(needMark){
-const b=ctx._cstBuf
-if(b!==undefined){
-const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
-const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
-const l=b.tl;${p}tl=l!==undefined?l.length:0
-}else{
-${p}raw=ctx._cstRawChildren!==undefined?ctx._cstRawChildren.length:0
-${p}tl=ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0
-${p}lv=ctx._cstLeaves!==undefined?ctx._cstLeaves.length:0
-}
-${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
-${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}
+        const xf = fxRef(code[ip + 2]);
+        return `${head}
+const v=${child}(input,pos,ctx)
+if(v===FAIL)ctx._fx=${xf}
+return v
 }`;
-        const my = `${p}my`;
-        const recFx = REC ? fxRef(code[ip + 6]) : "";
-        const sepSent = REC ? sentRef(code[ip + 7]) : "undefined";
-        const recSent = sep === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
-        const recGate = sep !== void 0 || min === 0 ? "" : `count>=${min}&&`;
-        const recBranch = !REC ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
-${sep === void 0 ? `${rb}
-` : ""}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
-${collect ? "out.push(rr.error)\n" : ""}captureError(ctx,rr.error)
-count++
-cur=rr.end
-continue
-}
-`;
+      }
+      case OP_FIELD: {
+        const name = q(k[code[ip + 1]]);
+        const child = link(code[ip + 2]);
         return `${head}
-const out=${collect ? "[]" : "undefined"}
-${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
-` : ""}let cur=pos
-let count=0
-for(;;){
-${max >= 0 ? `if(count>=${max})break
-` : ""}${sep !== void 0 ? `if(count>0&&count>=${min}&&cur>=input.length)break
-` : ""}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ""}${sinks.er ? `,${p}er=0` : ""}
-${markBody}
-let itemStart=cur
-let sepEnd=-1
-${sep !== void 0 ? `if(count>0){
-const lb=cstLeavesLen(ctx)
-let sp=cur
-${hasTrivia === "false" ? "" : hasTrivia === "true" ? `sp=${skip}(input,sp,ctx)
-` : `if(hasTrivia)sp=${skip}(input,sp,ctx)
-`}ctx._fc=false
-const sv=${sep}(input,sp,ctx)
-if(sv===FAIL){
-${rb}
-if(ctx._fc===true)return FAIL
-break
-}
-${keepSeparators ? "" : "demoteCapturedToRaw(ctx,lb)\n"}sepEnd=EC.e
-itemStart=${hasTrivia === "false" ? "EC.e" : hasTrivia === "true" ? `${skip}(input,EC.e,ctx)` : `hasTrivia?${skip}(input,EC.e,ctx):EC.e`}
-}else ${leadSkip(hasTrivia, leadTrivia, skip)}
-` : `${leadSkip(hasTrivia, leadTrivia, skip)}
-`}if(itemStart>=input.length&&${via}){
-${rb}
-${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
-}
-ctx._fc=false
-const v=${child}(input,itemStart,ctx)
-if(v===FAIL){
-${REC ? `if(ctx._fc===true){
-${rb}
-return FAIL
-}
-${recBranch}${rb}` : `${rb}
-if(ctx._fc===true)return FAIL`}
-${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
-}
-if(EC.e===itemStart&&${via}){
-${rb}
-break
-}
-${collect ? "out.push(v)\n" : ""}cur=EC.e
-count++
-}
-${min > 0 ? `if(count<${min}){
-${reportItem ? `ctx._fe=cur;ctx._fx=${itemFx}
-` : ""}return FAIL
+const v=${child}(input,pos,ctx)
+if(v===FAIL)return FAIL
+const f=ctx._fields
+if(f!==undefined)f.push({name:${name},value:v,span:{start:pos,end:EC.e}})
+return v
+}`;
+      }
+      case OP_EXPECT: {
+        const child = link(code[ip + 1]);
+        const xf = fxRef(code[ip + 2]);
+        return `${head}
+const v=${child}(input,pos,ctx)
+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
+EC.e=pos
+return err
+}`;
+      }
+      case OP_ROUTED: {
+        const fb = code[ip + 1];
+        const fallback = fb >= 0 ? link(fb) : void 0;
+        const push = `pushCstLeaf(ctx,{_tag:'leaf',value:it.value,span:it.span})`;
+        return `${head}
+const it=ctx._routed
+if(it===undefined||pos!==it.span.start){
+${fallback !== void 0 ? `return ${fallback}(input,pos,ctx)` : "ctx._fe=pos;ctx._fx=ROUTED_FX;return FAIL"}
 }
-` : ""}EC.e=cur
-return out
+${L.buf ? push : `if(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)${push}`}
+EC.e=it.span.end
+return it.value
 }`;
       }
-      case OP_NODE:
-      case OP_NODE_TRACK: {
-        const flags = code[ip + 3];
+      case OP_SCAN: {
+        const si = code[ip + 1];
+        return `${head}
+const r=SCANS[${si}].parse(input,pos,ctx)
+if(!r.ok){ctx._fe=r.span.start;ctx._fx=r.expected??EMPTY_FX;return FAIL}
+EC.e=r.span.end
+return r.value
+}`;
+      }
+      case OP_SCOPE:
+      case OP_SCOPE_CAP:
+      case OP_SCOPE_PLAIN: {
+        const ki = code[ip + 1];
+        const cap = op === OP_SCOPE_CAP;
+        const flags = op === OP_SCOPE_PLAIN ? 0 : code[ip + 3];
         const child = link(code[ip + 2]);
-        const proj = code[ip + 4];
-        const buildIdx = code[ip + 1];
-        const type = k[code[ip + 5]];
-        const tagIdx = code[ip + 6];
-        const tags = tagIdx < 0 ? "undefined" : kRef(tagIdx);
-        const tracked = op === OP_NODE_TRACK;
-        const readsTrivia = (flags & 4) !== 0;
-        const readsState = (flags & 8) !== 0;
-        const hasFields = (flags & 16) !== 0;
-        const collapse = (flags & 32) !== 0;
-        const unwrap = (flags & 64) !== 0;
-        const trailingTrivia = (flags & 128) !== 0;
-        const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
-        const structural = build === void 0 && proj < 0;
-        const grammarCapture = (flags & 1) !== 0 || trailingTrivia;
-        const hostCapturesThisType = structural && cfg.hostCaptureTrivia !== void 0 ? cfg.hostCaptureTrivia(type) : void 0;
-        const wantFields = hasFields || hostCst;
-        const captureWide = readsTrivia || hostCst ? !structural || grammarCapture || hostCapturesThisType !== false : hostCapturesThisType === true;
-        const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
-        const ty = q(type);
-        const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
-        const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
-        let value;
-        if (proj >= 0) {
-          value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:projectChild(kids,${proj},${ty})` : `nd=projectChild(kids,${proj},${ty})`;
-        } else if (build !== void 0) {
-          const direct = `${build}(kids,fieldMap,span,rawKids,${captureWide ? "tlog" : "EMPTY_TL"},st)`;
-          value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:${direct}` : `nd=${direct}`;
-        } else {
-          value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):{_tag:'node',type:${ty},span,state:st??null,children:kids}`;
-        }
-        const collapsible = keepChildren && (hostCst || build === void 0 && proj < 0);
-        const openCapture = keepChildren ? `const buf={}
-ctx._cstBuf=buf
-ctx._cstChildren=undefined
-ctx._cstLeaves=undefined
-ctx._cstRawChildren=undefined
-ctx._cstTriviaLog=undefined` : `const buf={rawOnly:true}
-ctx._cstBuf=buf
+        const scanFor = swapLegal && ki >= 0 && !triviaLabelled[ki] ? hoist("ts", `TRIVIASCAN[${ki}]`) : "null";
+        const tri = ki < 0 ? "undefined" : hoist("tv", `TRIVIA[${ki}]`);
+        const lab = ki < 0 ? "undefined" : hoist("tl", `TRIVIA[${ki}]._meta.triviaKindLabels`);
+        const strict = (flags & 2) !== 0 ? "refuseUnclassifiedRootScope(ctx._rootTriviaStrictScopes)\n" : "";
+        const rootCap = (flags & 1) !== 0;
+        return `${head}
+${strict}${rootCap ? "const sR=ctx._rootTriviaCapture\nctx._rootTriviaCapture=false\n" : ""}const sT=ctx.trivia,sL=ctx.triviaKindLabels,sS=_pfScan${cap ? ",sC=ctx.captureTrivia" : ""}
+_pfScan=${scanFor}
+ctx.trivia=${tri}
+ctx.triviaKindLabels=${lab}
+${cap ? "ctx.captureTrivia=true\n" : ""}const v=${child}(input,pos,ctx)
+${cap ? "ctx.captureTrivia=sC\n" : ""}ctx.trivia=sT
+ctx.triviaKindLabels=sL
+_pfScan=sS
+${rootCap ? "ctx._rootTriviaCapture=sR\n" : ""}return v
+}`;
+      }
+      /* ── boundaries ──────────────────────────────────────────────────────── */
+      case OP_TOKEN:
+      case OP_LEAF: {
+        const isToken = op === OP_TOKEN;
+        const fn = isToken ? void 0 : fnRef(code[ip + 1]);
+        const child = link(isToken ? code[ip + 1] : code[ip + 2]);
+        const wasCap = L.buf ? "true" : "(ctx._cstBuf!==undefined||ctx._cstLeaves!==undefined)";
+        return `${head}
+const sBuf=ctx._cstBuf,sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sOtl=ctx._triviaLog
+${isToken ? "const sTri=ctx.trivia,sKinds=ctx.triviaKindLabels,sScan=_pfScan,sRtl=ctx._rootTriviaLog\n" : ""}const wasCap=${wasCap}
+${isToken ? `_pfScan=null
+ctx.trivia=undefined
+ctx.triviaKindLabels=undefined
+` : ""}ctx._cstBuf=undefined
 ctx._cstChildren=undefined
 ctx._cstLeaves=undefined
 ctx._cstRawChildren=undefined
-ctx._cstTriviaLog=undefined`;
-        const finishCapture = keepChildren ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
-const hostKids=kids
-const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
-const tlog=buf.tl??EMPTY_TLOG` : `const kids=EMPTY_CH
-const hostKids=kids
-const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
-const tlog=buf.tl??EMPTY_TLOG`;
-        return `${head}
-const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
-const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
-${openCapture}
-ctx.captureTrivia=${captureWide}
-const savedFields=ctx._fields
-ctx._fields=${wantFields ? "[]" : "undefined"}
-${structural ? `const savedMask=ctx._triviaCaptureMask
-if(_pfHost!==undefined&&_pfHost._parsemanTriviaKinds!==undefined)ctx._triviaCaptureMask=_pfHost._parsemanTriviaKinds(${ty})
-` : ""}const v=${child}(input,pos,ctx)
-${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
-` : ""}const fieldMap=${wantFields ? "buildFieldMap(ctx._fields)" : "undefined"}
-ctx._fields=savedFields
-${structural ? "ctx._triviaCaptureMask=savedMask\n" : ""}${finishCapture}
-ctx._cstBuf=sBuf
+ctx._cstTriviaLog=undefined
+ctx._triviaLog=undefined
+${isToken ? "ctx._rootTriviaLog=undefined\n" : ""}let v
+try{v=${child}(input,pos,ctx)}finally{
+${isToken ? `_pfScan=sScan
+ctx.trivia=sTri
+ctx.triviaKindLabels=sKinds
+ctx._rootTriviaLog=sRtl
+` : ""}ctx._cstBuf=sBuf
 ctx._cstChildren=sCh
 ctx._cstLeaves=sLv
 ctx._cstRawChildren=sRaw
 ctx._cstTriviaLog=sTl
-ctx.captureTrivia=sCap
+ctx._triviaLog=sOtl
+}
 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"}
-let nd
-${unwrap ? "if(kids.length===1)nd=unwrapChild(kids[0])\nelse " : ""}${collapse ? "if(kids.length===1)nd=kids[0]\nelse " : ""}${collapsible ? `if(_pfHost!==undefined&&_pfHost._parsemanCstCollapse!==undefined&&kids.length===1&&rawKids.length===1&&_pfHost._parsemanCstCollapse(${ty},kids[0],kids,rawKids))nd=kids[0]
-else ` : ""}{${value}}
-${L.buf ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : "if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
-EC.e=end
-return nd
+const e=EC.e
+const out=${isToken ? "input.slice(pos,e)" : `${fn}(v,{start:pos,end:e})`}
+if(wasCap)pushCstLeaf(ctx,{_tag:'leaf',value:out,span:{start:pos,end:e}})
+EC.e=e
+return out
 }`;
       }
-      default:
-        throw new Unemittable(`OP_${OP_NAMES[op] ?? String(op)}`);
-    }
-  }
-  const ruleEntries = [];
-  for (const [rname, entryIp] of Object.entries(prog.rules)) {
-    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 source = `${RUNTIME_PRELUDE}
-${prelude.join("\n")}
-${skipDefs.join("\n")}
-${bodies.join("\n")}
-function _begin(ctx){
-const host=ctx.build
-if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
-_pfDepth++
-_pfScan=null
-_pfHost=host
-}
-function _finish(){
-if(_pfDepth<=0)throw new Error('parseman emitted table assembly frame underflow')
-_pfDepth--
-if(_pfDepth===0)return
-const prior=_pfFrames.pop()
-_pfScan=prior[0]
-_pfHost=prior[1]
-EC.e=prior[2]
+      /* ── transaction ─────────────────────────────────────────────────────── */
+      case OP_ATTEMPT: {
+        const child = link(code[ip + 1]);
+        const p = tmp();
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+if(v!==FAIL)return v
+${emitRollback(p, L.buf, sinks)}
+if(ctx._fc===true)return FAIL
+ctx._fe=pos
+return FAIL
+}`;
+      }
+      case OP_NOT: {
+        const child = link(code[ip + 1]);
+        const xf = fxRef(code[ip + 2]);
+        const p = tmp();
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+${emitRollback(p, L.buf, sinks)}
+if(v===FAIL){EC.e=pos;return null}
+ctx._fe=pos
+ctx._fx=${xf}
+return FAIL
+}`;
+      }
+      case OP_PEEK: {
+        const child = link(code[ip + 1]);
+        const xf = fxRef(code[ip + 2]);
+        const p = tmp();
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+const v=${child}(input,pos,ctx)
+${emitRollback(p, L.buf, sinks)}
+if(v===FAIL){ctx._fe=pos;ctx._fx=${xf};return FAIL}
+EC.e=pos
+return null
+}`;
+      }
+      case OP_OPT: {
+        const child = link(code[ip + 1]);
+        const p = tmp();
+        return `${head}
+${emitMark(p, L.buf, sinks)}
+ctx._fc=false
+const v=${child}(input,pos,ctx)
+if(v===FAIL){
+if(ctx._fc===true)return FAIL
+${emitRollback(p, L.buf, sinks)}
+EC.e=pos
+return null
 }
-return{
-pieces:{${ruleEntries.join(",")}},
-byIp:{${extra.join(",")}},
-end:function(){return EC.e},
-begin:_begin,
-finish:_finish
+return v
+}`;
+      }
+      case OP_SEQ:
+      case OP_SEQV:
+      case OP_SEQX: {
+        const fused = op === OP_SEQX;
+        const base = fused ? ip + 3 : ip + 2;
+        const n = code[fused ? ip + 2 : ip + 1];
+        const wantValues = op !== OP_SEQV;
+        for (let i = 1; i < n; i++) {
+          if (code[code[base + i]] === OP_ADJ) {
+            throw new Unemittable("a sequence carrying an adjacency assertion (OP_ADJ)");
+          }
+        }
+        const fn = fused ? fnRef(code[ip + 1]) : void 0;
+        const kids = [];
+        for (let i = 0; i < n; i++) kids.push(link(code[base + i]));
+        const sy = REC ? `${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));
+        parts.push(`const v0=${kids[0]}(input,pos,ctx)`, "if(v0===FAIL)return FAIL");
+        const close = () => REC ? `${parts.join("\n")}
+}finally{ctx._sync=${sy}}
+}` : `${parts.join("\n")}
 }`;
-  return {
-    source,
-    reached,
-    masks,
-    classes,
-    armExpected,
-    plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
-  };
+        if (n === 1) {
+          parts.push(fused ? `return ${fn}([v0],{start:pos,end:EC.e})` : wantValues ? "return [v0]" : "return undefined");
+          return close();
+        }
+        parts.push("let cur=EC.e");
+        const names = ["v0"];
+        for (let i = 1; i < n; i++) {
+          const vn = `v${i}`;
+          parts.push(`let ${vn}`);
+          if (REC) parts.push(pub(i));
+          parts.push(emitTerm(kids[i], vn, tmp(), L, skipFor(L)));
+          names.push(vn);
+        }
+        parts.push("EC.e=cur");
+        parts.push(fused ? `return ${fn}([${names.join(",")}],{start:pos,end:cur})` : wantValues ? `return [${names.join(",")}]` : "return undefined");
+        return close();
+      }
+      case OP_CHOICE: {
+        const table = disp[code[ip + 1]];
+        const n = code[ip + 2];
+        const choiceFx = fxRef(code[ip + 3]);
+        const base = ip + 4;
+        const arms = [];
+        for (let i = 0; i < n; i++) arms.push(link(code[base + i]));
+        const axi = armExpected.push(
+          Array.from({ length: n }, (_, i) => t.fx[code[base + n + i]])
+        ) - 1;
+        armExpectedPlan.push(Array.from({ length: n }, (_, i) => code[base + n + i]));
+        const afx = hoist("afx", `AFX[${axi}]`);
+        if (table.exclusive) {
+          const di = code[ip + 1];
+          const asc = hoist("as", `DISP[${di}].ascii`);
+          const hiArr = table.hi;
+          const armSwitch = arms.map((a, i) => `case ${i}:v=${a}(input,pos,ctx);break`).join("\n");
+          return `${head}
+const c=lead(input,pos)
+let arm=-1
+if(c>=0&&c<128){const a=${asc}[c];if(a!==0)arm=a-1}
+${hiArr.length === 0 ? "" : `else if(c>=128){const h=${hoist("hi", `DISP[${di}].hi`)}
+for(let i=0;i<h.length;i+=3){if(c>=h[i]&&c<=h[i+1]){arm=h[i+2];break}}}`}
+if(arm>=0){
+ctx._fc=false
+let v
+switch(arm){
+${armSwitch}
 }
-
-// src/table/run-support.ts
-function lineCol(ctx, offset) {
-  const starts = ctx._lineStarts ?? [0];
-  let lo = 0, hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
-  }
-  return [lo + 1, offset - starts[lo] + 1];
+if(v!==FAIL)return v
+if(ctx._fc===true)return FAIL
+const af=ctx._fx
+if(af!==undefined&&af.length>0){ctx._fe=pos;return FAIL}
 }
-function spanLines(ctx, start, end) {
-  const s = lineCol(ctx, start), e = lineCol(ctx, end);
-  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+ctx._fe=pos;ctx._fx=${choiceFx}
+return FAIL
+}`;
+        }
+        const ci = classes.push(Array.from({ length: n }, (_, i) => table.armCls[i] ?? null)) - 1;
+        classPlan.push(Array.from({ length: n }, (_, i) => prog.disp[code[ip + 1]][i] ?? -1));
+        const gates = classes[ci];
+        const gRef = hoist("g", `CLS[${ci}]`);
+        const maskable = n <= 32;
+        let maskName = "";
+        if (maskable) {
+          maskName = hoist("mk", `MASK[${masks.push(maskForClassRow(gates)) - 1}]`);
+          maskPlan.push(ci);
+        }
+        const p = tmp();
+        const maskArms = arms.map((a, i) => `
+if((bits&${1 << i})!==0){
+ctx._fc=false
+{const v=${a}(input,pos,ctx)
+if(v!==FAIL)return v}
+for(let j=prev;j<${i};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+prev=${i + 1}
+acc=_accSet(ctx._fx,acc)
+if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
+${emitRollback(p, L.buf, sinks)}
+}`).join("");
+        const generalArms = arms.map((a, i) => `
+if(${gRef}[${i}]===null||classHas(${gRef}[${i}],c)){
+ctx._fc=false
+{const v=${a}(input,pos,ctx)
+if(v!==FAIL)return v}
+acc=_accSet(ctx._fx,acc)
+if(ctx._fc===true){if(acc!==undefined)ctx._fx=acc;return FAIL}
+${emitRollback(p, L.buf, sinks)}
+}else acc=_accSet(${afx}[${i}],acc)`).join("");
+        return `${head}
+const c=lead(input,pos)
+${emitMark(p, L.buf, sinks)}
+let acc
+${maskable ? `if(c<128){
+const bits=${maskName}[c<0?128:c]
+let prev=0
+${maskArms}
+for(let j=prev;j<${n};j++)if((bits&(1<<j))===0)acc=_accSet(${afx}[j],acc)
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
+return FAIL
 }
-function rawEntry(v, input, s, e) {
-  if (typeof v === "object" && v !== null) {
-    const tg = v._tag;
-    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
-  }
-  return {
-    _tag: "leaf",
-    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
-    span: { start: s, end: e }
-  };
+` : ""}${generalArms}
+ctx._fe=pos;ctx._fx=acc??${choiceFx}
+return FAIL
+}`;
+      }
+      case OP_DISPATCH: {
+        const di = code[ip + 2];
+        const spec = dsp[di];
+        const selector = link(code[ip + 1]);
+        const otherIp = code[ip + 3];
+        const other = otherIp >= 0 ? link(otherIp) : void 0;
+        const otherRouted = code[ip + 4] === 1;
+        const n = code[ip + 5];
+        validateDispatchSpec(spec, n, code[ip + 4]);
+        const armBase = ip + 6;
+        const arms = [];
+        for (let i = 0; i < n; i++) arms.push(link(code[armBase + i]));
+        const bk = hoist("bk", `DSP[${di}].byKey`);
+        const dx = hoist("dx", `DSP[${di}].expected`);
+        const claims = (m) => {
+          switch (m[0]) {
+            case 0:
+              return `key.startsWith(${q(m[1])})`;
+            case 1:
+              return `key.endsWith(${q(m[1])})`;
+            case 3:
+              return `asciiFoldKey(key).startsWith(${q(m[1])})`;
+            case 4:
+              return `asciiFoldKey(key).endsWith(${q(m[1])})`;
+            default:
+              return `new RegExp(${q(m[1])},${q(m[2])}).test(key)`;
+          }
+        };
+        const chain = spec.match.length === 0 ? "" : `if(arm===undefined){
+${spec.match.map((m, i) => `${i === 0 ? "" : "else "}if(${claims(m)})arm=${m[3]}`).join("\n")}
 }
-function lead(input, pos) {
-  if (pos >= input.length) return -1;
-  const c = input.charCodeAt(pos);
-  if (c < 55296 || c > 56319) return c;
-  return input.codePointAt(pos) ?? c;
+`;
+        const fold = spec.byFold.size > 0 ? `if(arm===undefined)arm=${hoist("bf", `DSP[${di}].byFold`)}.get(asciiFoldKey(key))
+` : "";
+        const m1 = tmp();
+        const m2 = tmp();
+        const routedCall = (target) => `{const savedRouted=ctx._routed
+${emitRollback(m1, L.buf, sinks)}
+${emitMark(m2, L.buf, sinks, false)}
+ctx._routed={value:key,span:{start:pos,end:selEnd}}
+try{v=${target}(input,pos,ctx)}finally{ctx._routed=savedRouted}
+break}`;
+        const plainCall = (target) => `v=${target}(input,selEnd,ctx);break`;
+        const armCases = arms.map((target, i) => `case ${i}:${spec.routed[i] === 1 ? routedCall(target) : plainCall(target)}`).join("\n");
+        const fallbackCase = other === void 0 ? "" : `default:${otherRouted ? routedCall(other) : plainCall(other)}`;
+        return `${head}
+${emitMark(m1, L.buf, sinks)}
+const sv=${selector}(input,pos,ctx)
+if(sv===FAIL)return FAIL
+const selEnd=EC.e
+const key=sv
+let arm=${bk}.get(key)
+${fold}${chain}
+if(arm===undefined){
+${other === void 0 ? `ctx._fe=selEnd;ctx._fx=${dx};return FAIL` : ""}
 }
-
-// src/table/program.ts
-function closureArtifact(prog) {
-  return { ...prog, asm: [] };
+${emitMark(m2, L.buf, sinks)}
+let v
+switch(arm){
+${armCases}
+${fallbackCase}
 }
-function covKindCode(kind) {
-  switch (kind) {
-    case "rule":
-      return 0;
-    case "choice-arm":
-      return 1;
-    case "dispatch-arm":
-      return 2;
-    case "label":
-      return 3;
-  }
+if(v===FAIL){
+${emitRollback(m2, L.buf, sinks)}
+ctx._fc=true
+return FAIL
 }
-function covKindName(code) {
-  switch (code) {
-    case 0:
-      return "rule";
-    case 1:
-      return "choice-arm";
-    case 2:
-      return "dispatch-arm";
-    case 3:
-      return "label";
-  }
+return [key,v]
+}`;
+      }
+      case OP_REP:
+      case OP_REPV: {
+        const child = link(code[ip + 1]);
+        const min = code[ip + 2];
+        const max = code[ip + 3];
+        const sepIp = code[ip + 4];
+        const sep = sepIp >= 0 ? link(sepIp) : void 0;
+        const flags = code[ip + 5];
+        const keepSeparators = (flags & 2) !== 0;
+        const trailingAllowed = (flags & 1) !== 0;
+        const reportItem = (flags & 4) !== 0;
+        const itemFx = reportItem ? fxRef(code[ip + 6]) : "EMPTY_FX";
+        const collect = op === OP_REP;
+        const skipBeforeFirst = sepIp < 0 && min === 0;
+        const p = tmp();
+        const via = sep !== void 0 ? "false" : min === 0 ? skipBeforeFirst ? "true" : "count>0" : `count>=${min}&&count>0`;
+        const leadTrivia = skipBeforeFirst ? "true" : "count>0";
+        const skip = skipFor(L);
+        const knownTrivia = L.tri === TRI_NONE ? false : L.tri !== TRI_UNKNOWN ? true : void 0;
+        const hasTrivia = knownTrivia === void 0 ? "hasTrivia" : String(knownTrivia);
+        const needMark = L.buf ? "true" : "needMark";
+        const pfd = sinks.fd ? `${p}fd` : "0";
+        const per = sinks.er ? `${p}er` : "undefined";
+        const rb = L.buf ? `_rbBuf(ctx,${p}raw,${p}tl,${p}lv,${p}lg,${p}rt)${sinks.fd ? `
+if(ctx._fields!==undefined&&ctx._fields.length!==${p}fd)ctx._fields.length=${p}fd` : ""}${sinks.er ? `
+if(ctx._errors!==undefined&&ctx._errors.length!==${p}er)ctx._errors.length=${p}er` : ""}` : `if(needMark)rollbackTriviaAt(ctx,${p}raw,${p}tl,${p}lv,${pfd},${per},${p}lg,${p}rt)`;
+        const markSinks = `${sinks.fd ? `
+${p}fd=ctx._fields!==undefined?ctx._fields.length:0` : ""}${sinks.er ? `
+${p}er=ctx._errors!==undefined?ctx._errors.length:0` : ""}`;
+        const markBody = L.buf ? `const b=ctx._cstBuf
+const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${p}tl=l!==undefined?l.length:0
+${p}lg=ctx._triviaLog!==undefined?ctx._triviaLog.length:0
+${p}rt=ctx._rootTriviaLog!==undefined?ctx._rootTriviaLog.length:0${markSinks}` : `if(needMark){
+const b=ctx._cstBuf
+if(b!==undefined){
+const r=b.raw;${p}raw=r!==undefined?r.length:b.rawSingle!==undefined?1:0
+const h=b.ch;${p}lv=h!==undefined?h.length:b.single!==undefined?1:0
+const l=b.tl;${p}tl=l!==undefined?l.length:0
+}else{
+${p}raw=ctx._cstRawChildren!==undefined?ctx._cstRawChildren.length:0
+${p}tl=ctx._cstTriviaLog!==undefined?ctx._cstTriviaLog.length:0
+${p}lv=ctx._cstLeaves!==undefined?ctx._cstLeaves.length:0
 }
-function covDefinitions(prog) {
-  return (prog.cov ?? []).map(([id, kind]) => ({ id, kind: covKindName(kind) }));
+${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 recSent = sep === void 0 ? my : sepSent === "undefined" ? `orSentinel(${my},undefined)` : `orSentinel(${sepSent}??${my},${sepSent}===undefined?undefined:${my})`;
+        const recGate = sep !== void 0 || min === 0 ? "" : `count>=${min}&&`;
+        const recBranch = !REC ? "" : `if(ctx._tolerant===true&&${my}!==undefined&&${recGate}!matchesAt(${my},input,itemStart,ctx)){
+${sep === void 0 ? `${rb}
+` : ""}const rr=recoverScan(input,itemStart,ctx,${recSent},${recFx})
+${collect ? "out.push(rr.error)\n" : ""}captureError(ctx,rr.error)
+count++
+cur=rr.end
+continue
 }
-function expandCompact(p) {
-  if ("code" in p) return p;
-  return ownTableProgram({
-    code: p.c,
-    k: p.k,
-    cc: p.x,
-    fx: p.e,
-    disp: p.d,
-    rules: p.r,
-    fns: p.f,
-    lines: p.l ?? 0,
-    dsp: p.p ?? [],
-    ...p.lb === void 0 ? {} : { labels: p.lb },
-    ...p.rc === void 0 ? {} : { classified: p.rc },
-    ...p.h === void 0 ? {} : { hostMode: p.h },
-    ...p.tv === void 0 ? {} : { triviaSpecs: p.tv },
-    ...p.sc === void 0 ? {} : { scans: p.sc },
-    ...p.ss === void 0 ? {} : { scanSkip: p.ss },
-    ...p.so === void 0 ? {} : { scanSkipOf: p.so },
-    ...p.rv === void 0 ? {} : { rec: p.rv },
-    ...p.cv === void 0 ? {} : { cov: p.cv },
-    ...p.a === void 0 ? {} : { asm: p.a }
-  });
+`;
+        return `${head}
+const out=${collect ? "[]" : "undefined"}
+${knownTrivia === void 0 ? "const hasTrivia=ctx.trivia!==undefined\n" : ""}${L.buf ? "" : "const needMark=_rollbackNeeded(ctx)\n"}${REC ? `const ${my}=ctx._sync
+` : ""}let cur=pos
+let count=0
+for(;;){
+${max >= 0 ? `if(count>=${max})break
+` : ""}${sep !== void 0 ? `if(count>0&&count>=${min}&&cur>=input.length)break
+` : ""}let ${p}raw=0,${p}tl=0,${p}lv=0,${p}lg=0,${p}rt=0${sinks.fd ? `,${p}fd=0` : ""}${sinks.er ? `,${p}er=0` : ""}
+${markBody}
+let itemStart=cur
+let sepEnd=-1
+${sep !== void 0 ? `if(count>0){
+const lb=cstLeavesLen(ctx)
+let sp=cur
+${hasTrivia === "false" ? "" : hasTrivia === "true" ? `sp=${skip}(input,sp,ctx)
+` : `if(hasTrivia)sp=${skip}(input,sp,ctx)
+`}ctx._fc=false
+const sv=${sep}(input,sp,ctx)
+if(sv===FAIL){
+${rb}
+if(ctx._fc===true)return FAIL
+break
 }
-var TABLE_RUNTIME = /* @__PURE__ */ Symbol("parseman.tableRuntime");
-function ownTableProgram(prog, resolved) {
-  return { ...prog, [TABLE_RUNTIME]: { resolved } };
+${keepSeparators ? "" : "demoteCapturedToRaw(ctx,lb)\n"}sepEnd=EC.e
+itemStart=${hasTrivia === "false" ? "EC.e" : hasTrivia === "true" ? `${skip}(input,EC.e,ctx)` : `hasTrivia?${skip}(input,EC.e,ctx):EC.e`}
+}else ${leadSkip(hasTrivia, leadTrivia, skip)}
+` : `${leadSkip(hasTrivia, leadTrivia, skip)}
+`}if(itemStart>=input.length&&${via}){
+${rb}
+${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
-var WIDE_CLASS_PREFIX_LO = 65535;
-var WIDE_CLASS_PREFIX_HI = 0;
-function validateClassRange(lo, hi) {
-  for (const cp of [lo, hi]) {
-    if (!Number.isInteger(cp) || cp < 0 || cp > 1114111) {
-      throw new TypeError(`table char-class endpoint is outside Unicode: ${cp}`);
-    }
-  }
-  if (lo > hi) {
-    throw new TypeError(`table char-class range is descending: ${lo} > ${hi}`);
-  }
+ctx._fc=false
+const v=${child}(input,itemStart,ctx)
+if(v===FAIL){
+${REC ? `if(ctx._fc===true){
+${rb}
+return FAIL
 }
-function encodeClassSpec(ranges) {
-  let wide = false;
-  for (const range of ranges) {
-    validateClassRange(range.lo, range.hi);
-    if (range.hi > 65535) wide = true;
-  }
-  if (!wide) {
-    let spec2 = "";
-    for (const range of ranges) spec2 += String.fromCharCode(range.lo, range.hi);
-    return spec2;
-  }
-  let spec = String.fromCharCode(WIDE_CLASS_PREFIX_LO, WIDE_CLASS_PREFIX_HI);
-  for (const range of ranges) {
-    spec += String.fromCharCode(
-      range.lo >>> 16,
-      range.lo & 65535,
-      range.hi >>> 16,
-      range.hi & 65535
-    );
-  }
-  return spec;
+${recBranch}${rb}` : `${rb}
+if(ctx._fc===true)return FAIL`}
+${trailingAllowed ? "if(sepEnd>=0)cur=sepEnd\n" : ""}break
 }
-function decodeClassSpec(spec) {
-  if (spec.charCodeAt(0) === WIDE_CLASS_PREFIX_LO && spec.charCodeAt(1) === WIDE_CLASS_PREFIX_HI) {
-    if ((spec.length - 2) % 4 !== 0) throw new TypeError("table char-class spec has a truncated wide range");
-    if (spec.length === 2) throw new TypeError("table char-class spec has a wide prefix but no ranges");
-    const ranges2 = [];
-    for (let i = 2; i < spec.length; i += 4) {
-      const lo = spec.charCodeAt(i) * 65536 + spec.charCodeAt(i + 1);
-      const hi = spec.charCodeAt(i + 2) * 65536 + spec.charCodeAt(i + 3);
-      validateClassRange(lo, hi);
-      ranges2.push({ lo, hi });
-    }
-    return ranges2;
-  }
-  if (spec.length % 2 !== 0) throw new TypeError("table char-class spec has an unmatched range endpoint");
-  const ranges = [];
-  for (let i = 0; i < spec.length; i += 2) {
-    const lo = spec.charCodeAt(i);
-    const hi = spec.charCodeAt(i + 1);
-    validateClassRange(lo, hi);
-    ranges.push({ lo, hi });
-  }
-  return ranges;
+if(EC.e===itemStart&&${via}){
+${rb}
+break
 }
-function resolveClass(spec) {
-  const ascii = new Uint8Array(128);
-  const hi = [];
-  for (const { lo, hi: up } of decodeClassSpec(spec)) {
-    if (lo < 128) for (let c = lo; c <= Math.min(up, 127); c++) ascii[c] = 1;
-    if (up >= 128) hi.push(Math.max(lo, 128), up);
-  }
-  return { ascii, hi };
+${collect ? "out.push(v)\n" : ""}cur=EC.e
+count++
 }
-function classHas(cls, code) {
-  if (code < 0) return false;
-  if (code < 128) return cls.ascii[code] === 1;
-  const hi = cls.hi;
-  for (let i = 0; i < hi.length; i += 2) if (code >= hi[i] && code <= hi[i + 1]) return true;
-  return false;
+${min > 0 ? `if(count<${min}){
+${reportItem ? `ctx._fe=cur;ctx._fx=${itemFx}
+` : ""}return FAIL
 }
-function resolveDispatch(arms, cc) {
-  const ascii = new Uint8Array(128);
-  const hi = [];
-  const open = [];
-  const armCls = [];
-  let exclusive = true;
-  let hiOwners = 0;
-  for (let a = 0; a < arms.length; a++) {
-    const ci = arms[a];
-    if (ci < 0) {
-      open.push(a);
-      armCls.push(null);
-      exclusive = false;
-      continue;
-    }
-    const cls = cc[ci];
-    armCls.push(cls);
-    for (let c = 0; c < 128; c++) {
-      if (cls.ascii[c] !== 1) continue;
-      if (ascii[c] === 0) ascii[c] = a + 1;
-      else exclusive = false;
+` : ""}EC.e=cur
+return out
+}`;
+      }
+      case OP_NODE:
+      case OP_NODE_TRACK: {
+        const flags = code[ip + 3];
+        const child = link(code[ip + 2]);
+        const proj = code[ip + 4];
+        const buildIdx = code[ip + 1];
+        const type = k[code[ip + 5]];
+        const tagIdx = code[ip + 6];
+        const tags = tagIdx < 0 ? "undefined" : kRef(tagIdx);
+        const tracked = op === OP_NODE_TRACK;
+        const readsTrivia = (flags & 4) !== 0;
+        const readsState = (flags & 8) !== 0;
+        const hasFields = (flags & 16) !== 0;
+        const collapse = (flags & 32) !== 0;
+        const unwrap = (flags & 64) !== 0;
+        const trailingTrivia = (flags & 128) !== 0;
+        const build = buildIdx >= 0 ? fnRef(buildIdx) : void 0;
+        const structural = build === void 0 && proj < 0;
+        const grammarCapture = (flags & 1) !== 0 || trailingTrivia;
+        const hostCapturesThisType = structural && cfg.hostCaptureTrivia !== void 0 ? cfg.hostCaptureTrivia(type) : void 0;
+        const wantFields = hasFields || hostCst;
+        const captureWide = readsTrivia || hostCst ? !structural || grammarCapture || hostCapturesThisType !== false : hostCapturesThisType === true;
+        const keepChildren = !structural || cfg.hostReadsChildren !== false || collapse || unwrap;
+        const ty = q(type);
+        const stArg = readsState ? "st" : "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)";
+        const hostCall = `_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,${stArg},${tags})`;
+        let value;
+        if (proj >= 0) {
+          value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:projectChild(kids,${proj},${ty})` : `nd=projectChild(kids,${proj},${ty})`;
+        } else if (build !== void 0) {
+          const direct = `${build}(kids,fieldMap,span,rawKids,${captureWide ? "tlog" : "EMPTY_TL"},st)`;
+          value = hostCst ? `nd=_pfHost!==undefined?${hostCall}:${direct}` : `nd=${direct}`;
+        } else {
+          value = `nd=_pfHost!==undefined?_pfHost(${ty},hostKids,fieldMap,span,rawKids,tlog,st,${tags}):{_tag:'node',type:${ty},span,state:st??null,children:kids}`;
+        }
+        const collapsible = keepChildren && (hostCst || build === void 0 && proj < 0);
+        const openCapture = keepChildren ? `const buf={}
+ctx._cstBuf=buf
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined` : `const buf={rawOnly:true}
+ctx._cstBuf=buf
+ctx._cstChildren=undefined
+ctx._cstLeaves=undefined
+ctx._cstRawChildren=undefined
+ctx._cstTriviaLog=undefined`;
+        const finishCapture = keepChildren ? `const kids=buf.ch??(buf.single!==undefined?[buf.single]:EMPTY_CH)
+const hostKids=kids
+const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
+const tlog=buf.tl??EMPTY_TLOG` : `const kids=EMPTY_CH
+const hostKids=kids
+const rawKids=buf.raw??(buf.rawSingle!==undefined?[buf.rawSingle]:EMPTY_CH)
+const tlog=buf.tl??EMPTY_TLOG`;
+        return `${head}
+const sCh=ctx._cstChildren,sLv=ctx._cstLeaves,sRaw=ctx._cstRawChildren,sTl=ctx._cstTriviaLog
+const sCap=ctx.captureTrivia,sBuf=ctx._cstBuf
+${openCapture}
+ctx.captureTrivia=${captureWide}
+const savedFields=ctx._fields
+ctx._fields=${wantFields ? "[]" : "undefined"}
+${structural ? `const savedMask=ctx._triviaCaptureMask
+if(_pfHost!==undefined&&_pfHost._parsemanTriviaKinds!==undefined)ctx._triviaCaptureMask=_pfHost._parsemanTriviaKinds(${ty})
+` : ""}const v=${child}(input,pos,ctx)
+${trailingTrivia && L.tri !== TRI_NONE ? `if(v!==FAIL${L.tri === TRI_UNKNOWN ? "&&ctx.trivia!==undefined" : ""})EC.e=consumeTrivia(input,EC.e,ctx)
+` : ""}const fieldMap=${wantFields ? "buildFieldMap(ctx._fields)" : "undefined"}
+ctx._fields=savedFields
+${structural ? "ctx._triviaCaptureMask=savedMask\n" : ""}${finishCapture}
+ctx._cstBuf=sBuf
+ctx._cstChildren=sCh
+ctx._cstLeaves=sLv
+ctx._cstRawChildren=sRaw
+ctx._cstTriviaLog=sTl
+ctx.captureTrivia=sCap
+if(v===FAIL)return FAIL
+const end=EC.e
+const span=${tracked ? "spanLines(ctx,pos,end)" : "{start:pos,end}"}
+const st=${readsState ? "(ctx.state!==undefined?Object.assign({},ctx.state):undefined)" : "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}}
+${L.buf ? "pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))" : "if(sBuf!==undefined||sCh!==undefined)pushCstChild(ctx,nd,rawEntry(nd,input,pos,end))"}
+EC.e=end
+return nd
+}`;
+      }
+      default:
+        throw new Unemittable(`OP_${OP_NAMES[op] ?? String(op)}`);
     }
-    if (cls.hi.length > 0 && ++hiOwners > 1) exclusive = false;
-    for (let i = 0; i < cls.hi.length; i += 2) hi.push(cls.hi[i], cls.hi[i + 1], a);
   }
-  return { ascii, hi, open, armCls, exclusive };
-}
-function buildTrivia(spec) {
-  if (spec.live !== void 0) return spec.live;
-  if (spec.plain !== void 0) return trivia(regex(new RegExp(spec.plain[0], spec.plain[1])));
-  if (spec.alts !== void 0) {
-    const [head, ...rest] = spec.alts.map(([source, flags]) => regex(new RegExp(source, flags)));
-    if (head === void 0) throw new TypeError("trivia spec has an EMPTY alternation, which matches nothing");
-    const body = rest.length === 0 ? head : choice(head, ...rest);
-    return trivia(many(body, { min: spec.min ?? 1 }));
+  const ruleEntries = [];
+  for (const [rname, entryIp] of Object.entries(prog.rules)) {
+    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 arms = {};
-  for (const [name, source, flags] of spec.arms) arms[name] = regex(new RegExp(source, flags));
-  return classifiedTrivia(arms);
+  const extra = [];
+  for (const ip of extraIps) extra.push(`${ip}:${link(ip)}`);
+  const source = `${RUNTIME_PRELUDE}
+${prelude.join("\n")}
+${skipDefs.join("\n")}
+${bodies.join("\n")}
+function _begin(ctx){
+const host=ctx.build
+if(_pfDepth>0)_pfFrames.push([_pfScan,_pfHost,EC.e])
+_pfDepth++
+_pfScan=null
+_pfHost=host
 }
-function resolveTable(prog) {
-  const owner = prog[TABLE_RUNTIME];
-  const hit = owner?.resolved;
-  if (hit !== void 0) return hit;
-  const cc = prog.cc.map(resolveClass);
-  const triviaBuilt = (prog.triviaSpecs ?? []).map(buildTrivia);
-  const built = {
-    prog,
-    code: Int32Array.from(prog.code),
-    k: prog.k,
-    fns: prog.fns,
-    cc,
-    fx: prog.fx,
-    disp: prog.disp.map((d) => resolveDispatch(d, cc)),
-    trivia: triviaBuilt,
-    triviaScan: triviaBuilt.map(fastTriviaScanner),
-    triviaLabelled: triviaBuilt.map((t) => t._meta.triviaKindLabels !== void 0),
-    dsp: prog.dsp.map((d) => ({
-      byKey: new Map(d.key.map((x, i) => [x, d.keyArm[i]])),
-      byFold: new Map(d.fold.map((x, i) => [x, d.foldArm[i]])),
-      match: d.match,
-      routed: d.routed,
-      expected: d.expected
-    })),
-    rules: prog.rules
-  };
-  if (owner !== void 0) owner.resolved = built;
-  return built;
+function _finish(){
+if(_pfDepth<=0)throw new Error('parseman emitted table assembly frame underflow')
+_pfDepth--
+if(_pfDepth===0)return
+const prior=_pfFrames.pop()
+_pfScan=prior[0]
+_pfHost=prior[1]
+EC.e=prior[2]
 }
-var FOLDED_RUNTIME = /* @__PURE__ */ Symbol("parseman.foldedRuntime");
-function ownFoldedProgram(base, variants) {
-  return { base, variants, [FOLDED_RUNTIME]: { byName: /* @__PURE__ */ new Map() } };
+return{
+pieces:{${ruleEntries.join(",")}},
+byIp:{${extra.join(",")}},
+end:function(){return EC.e},
+begin:_begin,
+finish:_finish
+}`;
+  return {
+    source,
+    reached,
+    masks,
+    classes,
+    armExpected,
+    plan: { classes: classPlan, armExpected: armExpectedPlan, masks: maskPlan }
+  };
 }
-var SHARED_FIELDS = [
-  "k",
-  "cc",
-  "fx",
-  "disp",
-  "dsp",
-  "rules",
-  "labels",
-  "classified",
-  "scanSkip",
-  "scanSkipOf",
-  "scans",
-  "triviaSpecs",
-  "runtimeOnly",
-  // `rec` is a property of the GRAMMAR BUILD, not of the trackLines/hostMode
-  // axis a fold varies — every variant of one export is encoded with the same
-  // recovery setting, and a mismatch is two tables, which is what the refusal says.
-  "rec",
-  // `cov` is a property of the GRAMMAR and its coverage plan, for the same reason
-  // `rec` is a property of the build: the plan is built from the rule map, which
-  // every variant of one export shares. It ships ONCE, and a variant that
-  // disagrees is two tables — which is what the refusal says.
-  "cov"
-];
-function foldPrograms(programs, baseName) {
-  const suppliedBase = programs[baseName];
-  if (suppliedBase === void 0) throw new TypeError(`foldPrograms: no program named ${JSON.stringify(baseName)}`);
-  const base = closureArtifact(suppliedBase);
-  const variants = {};
-  for (const name of Object.keys(programs)) {
-    const p = programs[name];
-    if (p.asm !== void 0 && p.asm.length > 0) {
-      throw new TypeError(
-        `foldPrograms: program ${JSON.stringify(name)} already carries pre-compiled assemblies. An assembly is emitted from a \`code\` stream and a fold overwrites \`code\` per variant, so pre-compiling must happen AFTER the fold, per variant \u2014 not before it.`
-      );
-    }
-    if (p.code.length !== base.code.length) {
-      throw new TypeError(
-        `foldPrograms: variant ${JSON.stringify(name)} has ${p.code.length} code words, base ${JSON.stringify(baseName)} has ${base.code.length}. A fold overwrites words; it cannot resize the stream. These are two different tables, not one table and its edits.`
-      );
-    }
-    for (const f of SHARED_FIELDS) {
-      if (JSON.stringify(p[f]) !== JSON.stringify(base[f])) {
-        throw new TypeError(
-          `foldPrograms: variant ${JSON.stringify(name)} differs from base ${JSON.stringify(baseName)} in ${JSON.stringify(f)}, which the fold ships ONCE. Either the variants are not encodings of one grammar, or this field has become variant-dependent and needs its own delta.`
-        );
-      }
-    }
-    if (p.fns.length !== base.fns.length || p.fns.some((f, i) => f !== base.fns[i])) {
-      throw new TypeError(
-        `foldPrograms: variant ${JSON.stringify(name)} does not share the base's reducer pool BY IDENTITY. Equal source text is not enough \u2014 two closures can print alike and capture different scopes. Encode every variant from ONE grammar export.`
-      );
-    }
-    const at = [];
-    const to = [];
-    let prev = 0;
-    for (let i = 0; i < p.code.length; i++) {
-      if (p.code[i] === base.code[i]) continue;
-      at.push(i - prev);
-      to.push(p.code[i]);
-      prev = i;
-    }
-    variants[name] = {
-      at,
-      to,
-      ...p.lines === void 0 ? {} : { lines: p.lines },
-      ...p.hostMode === void 0 ? {} : { hostMode: p.hostMode }
-    };
+
+// src/table/run-support.ts
+function lineCol(ctx, offset) {
+  const starts = ctx._lineStarts ?? [0];
+  let lo = 0, hi = starts.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (starts[mid] <= offset) lo = mid;
+    else hi = mid - 1;
   }
-  return ownFoldedProgram(base, variants);
+  return [lo + 1, offset - starts[lo] + 1];
 }
-function unfoldVariant(folded, name) {
-  const byName = folded[FOLDED_RUNTIME]?.byName;
-  const hit = byName?.get(name);
-  if (hit !== void 0) return hit;
-  const d = folded.variants[name];
-  if (d === void 0) {
-    throw new TypeError(
-      `unfoldVariant: no variant ${JSON.stringify(name)}. This table carries: ${Object.keys(folded.variants).map((n) => JSON.stringify(n)).join(", ")}.`
-    );
-  }
-  const base = folded.base;
-  const code = [...base.code];
-  let ip = 0;
-  for (let i = 0; i < d.at.length; i++) {
-    ip += d.at[i];
-    code[ip] = d.to[i];
+function spanLines(ctx, start, end) {
+  const s = lineCol(ctx, start), e = lineCol(ctx, end);
+  return { start, end, startLine: s[0], startColumn: s[1], endLine: e[0], endColumn: e[1] };
+}
+function rawEntry(v, input, s, e) {
+  if (typeof v === "object" && v !== null) {
+    const tg = v._tag;
+    if (tg === "node" || tg === "leaf" || tg === "parseError") return v;
   }
-  const raw = {
-    ...base,
-    code,
-    ...d.lines === void 0 ? {} : { lines: d.lines },
-    ...d.hostMode === void 0 ? {} : { hostMode: d.hostMode }
+  return {
+    _tag: "leaf",
+    value: typeof v === "string" ? v : typeof v === "object" && v !== null ? input.slice(s, e) : "",
+    span: { start: s, end: e }
   };
-  const prog = ownTableProgram(raw);
-  const owner = prog[TABLE_RUNTIME];
-  owner.resolved = { ...resolveTable(base), prog, code: Int32Array.from(code) };
-  byName?.set(name, prog);
-  return prog;
 }
-function expandCompactFolded(f) {
-  const variants = {};
-  for (const name of Object.keys(f.v)) {
-    const d = f.v[name];
-    variants[name] = {
-      at: d.a ?? [],
-      to: d.t ?? [],
-      ...d.l === void 0 ? {} : { lines: d.l },
-      ...d.h === void 0 ? {} : { hostMode: d.h }
-    };
-  }
-  return ownFoldedProgram(expandCompact(f.b), variants);
+function lead(input, pos) {
+  if (pos >= input.length) return -1;
+  const c = input.charCodeAt(pos);
+  if (c < 55296 || c > 56319) return c;
+  return input.codePointAt(pos) ?? c;
 }
 
 // src/cst/host-mode.ts
@@ -6289,7 +6355,7 @@ function committed(c) {
 }
 function stampRuleMap(prog, d, artifactMetadata = {}, resolved = resolveTable(prog)) {
   const triviaOfRule = (ip) => {
-    if (prog.code[ip] !== OP_SCOPE) return void 0;
+    if (prog.code[ip] !== OP_SCOPE_PLAIN && prog.code[ip] !== OP_SCOPE) return void 0;
     const slot = prog.code[ip + 1];
     return slot < 0 ? void 0 : resolved.trivia[slot];
   };
@@ -6509,20 +6575,19 @@ function assemble(t, prog, cfg) {
       TERMV = v2;
       return EC.e > scanEnd2 ? EC.e : cur;
     }
-    const need = markCst(ctx);
-    const mRaw = MRAW;
-    const mTl = MTL;
-    const mLv = MLV;
-    const mFl = need ? ctx._fields?.length ?? 0 : 0;
-    const mEr = need ? ctx._errors?.length ?? 0 : 0;
+    const need = rollbackNeeded(ctx);
+    const mTl = need ? cstTlLen(ctx) : 0;
     const mLog = need ? ctx._triviaLog?.length ?? 0 : 0;
     const mRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
     const scanEnd = skipTrivia(input, cur, ctx);
+    const scanTl = need ? cstTlLen(ctx) : 0;
+    const scanLog = need ? ctx._triviaLog?.length ?? 0 : 0;
+    const scanRoot = need ? ctx._rootTriviaLog?.length ?? 0 : 0;
     const v = child(input, scanEnd, ctx);
     if (v === FAIL) return -1;
     TERMV = v;
     if (EC.e > scanEnd) return EC.e;
-    if (need) rollbackTriviaAt(ctx, mRaw, mTl, mLv, mFl, mEr, mLog, mRoot);
+    if (need) rollbackScannedTriviaAt(ctx, mTl, scanTl, mLog, scanLog, mRoot, scanRoot);
     return cur;
   }
   function committed2(c) {
@@ -6936,7 +7001,8 @@ function assemble(t, prog, cfg) {
         };
       }
       case OP_SCOPE:
-      case OP_SCOPE_CAP: {
+      case OP_SCOPE_CAP:
+      case OP_SCOPE_PLAIN: {
         const ki = code[ip + 1];
         const scopeTrivia = ki < 0 ? void 0 : trivia2[ki];
         const scopeLabels = scopeTrivia?._meta.triviaKindLabels;
@@ -6970,7 +7036,7 @@ function assemble(t, prog, cfg) {
           SCAN = savedScan;
           return v;
         };
-        return scopeRootPolicy(scopePiece, code[ip + 3]);
+        return scopeRootPolicy(scopePiece, code[ip] === OP_SCOPE_PLAIN ? 0 : code[ip + 3]);
       }
       case OP_ROUTED: {
         const fb = code[ip + 1];
@@ -7886,15 +7952,21 @@ function assemble(t, prog, cfg) {
             target = arms[arm];
             usesRouted = routed[arm] === 1;
           }
-          const savedRouted = ctx._routed;
           let mark = saveTriviaMark(ctx);
+          let v;
           if (usesRouted) {
+            const savedRouted = ctx._routed;
             rollbackTrivia(ctx, selectorMark);
             mark = saveTriviaMark(ctx);
             ctx._routed = { value: key, span: { start: pos, end: selEnd } };
+            try {
+              v = target(input, pos, ctx);
+            } finally {
+              ctx._routed = savedRouted;
+            }
+          } else {
+            v = target(input, selEnd, ctx);
           }
-          const v = target(input, usesRouted ? pos : selEnd, ctx);
-          if (usesRouted) ctx._routed = savedRouted;
           if (v === FAIL) {
             rollbackTrivia(ctx, mark);
             ctx._fc = true;
@@ -8040,6 +8112,11 @@ function assemble(t, prog, cfg) {
       if (s.sentinel !== void 0) extraIps.push(s.sentinel[0]);
     }
     for (const set of prog.scanSkip ?? []) for (const r of set) extraIps.push(r[0]);
+    const validationRoots = [...Object.values(prog.rules), ...extraIps];
+    for (const ip of reachableSites(code, validationRoots)) {
+      if (code[ip] !== OP_DISPATCH) continue;
+      validateDispatchSpec(dsp[code[ip + 2]], code[ip + 5], code[ip + 4]);
+    }
     const pre = cfg.hostCaptureTrivia === void 0 ? prog.asm?.find((a) => a.key === cfgKey(cfg)) : void 0;
     if (pre !== void 0) {
       const pools = rebuildPools(t.cc, t.fx, pre.plan);
@@ -8066,6 +8143,7 @@ function assemble(t, prog, cfg) {
         pushCstLeaf,
         pushCstChild,
         rollbackTriviaAt,
+        rollbackScannedTriviaAt,
         failAt,
         classHas,
         consumeTrivia,
@@ -8136,6 +8214,7 @@ function assemble(t, prog, cfg) {
         pushCstLeaf,
         pushCstChild,
         rollbackTriviaAt,
+        rollbackScannedTriviaAt,
         failAt,
         classHas,
         consumeTrivia,
@@ -8825,7 +8904,7 @@ var Encoder = class {
     this.carryTriviaMeta(amb);
     this.carryTriviaMeta(p);
     if (p._def.tag === "grammar") this.carryTriviaMeta(p._def.triviaParser);
-    this.rules[name] = amb === void 0 ? body : this.emit(OP_SCOPE, this.triviaSlot(amb), body);
+    this.rules[name] = amb === void 0 ? body : this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), body);
   }
   /**
    * The row a cross-rule `g.X` reference jumps to — the target's body, RE-WRAPPED
@@ -8868,7 +8947,7 @@ var Encoder = class {
     const amb = p._meta.grammarTrivia ?? target._meta.grammarTrivia;
     if (amb === void 0 || this.activeTrivia !== void 0) return ip;
     if (!hasOwnTriviaBoundary(target)) return ip;
-    return this.emit(OP_SCOPE, this.triviaSlot(amb), ip);
+    return this.emit(OP_SCOPE_PLAIN, this.triviaSlot(amb), ip);
   }
   node(p) {
     const lazyRef = p._def.tag === "lazy";
@@ -9273,6 +9352,7 @@ var Encoder = class {
           return [ip + 1];
         case OP_SCOPE:
         case OP_SCOPE_CAP:
+        case OP_SCOPE_PLAIN:
         case OP_WITHCTX:
         case OP_XFORM:
         case OP_LEAF:
@@ -9412,6 +9492,14 @@ function encodeTableProgram(ruleMap, settings = {}) {
 function jsString(s) {
   return JSON.stringify(s);
 }
+function emitClassPool(classes) {
+  const array = `[${classes.map(jsString).join(",")}]`;
+  if (classes.length < 2) return array;
+  const delimiter = "|/~?^`".split("").find((ch2) => classes.every((spec) => !spec.includes(ch2)));
+  if (delimiter === void 0) return array;
+  const split = `${jsString(classes.join(delimiter))}.split(${jsString(delimiter)})`;
+  return split.length < array.length ? split : array;
+}
 function emitConst(v) {
   if (v instanceof RegExp) return `/${v.source}/${v.flags}`;
   if (typeof v === "string") return jsString(v);
@@ -9490,7 +9578,7 @@ function programFields(prog, fns, opts = {}) {
     ...emitAssemblies(prog, opts.assemblies ?? []),
     `c:[${prog.code.join(",")}],`,
     `k:[${prog.k.map(emitConst).join(",")}],`,
-    `x:[${prog.cc.map(jsString).join(",")}],`,
+    `x:${emitClassPool(prog.cc)},`,
     `e:[${prog.fx.map((f) => `[${f.map(jsString).join(",")}]`).join(",")}],`,
     `d:[${prog.disp.map((a) => `[${a.join(",")}]`).join(",")}],`,
     `r:${JSON.stringify(prog.rules)},`,