parseman 0.15.0 → 0.17.0

package/dist/plugin/index.cjs

@@ -126,6 +126,54 @@ function sequenceFirstSet(parsers) {
   }
   return fs2;
 }
+function firstSetOf(p, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(p)) return any();
+  seen.add(p);
+  const fs2 = (c) => firstSetOf(c, seen);
+  const d = p._def;
+  switch (d.tag) {
+    case "literal":
+    case "regex":
+    case "keywords":
+      return p._meta.firstSet;
+    // terminals: no refs, cached set is exact
+    case "lazy":
+      try {
+        return fs2(d.thunk());
+      } catch {
+        return any();
+      }
+    case "choice": {
+      let out = empty();
+      for (const arm of d.parsers) out = union(out, fs2(arm));
+      return out;
+    }
+    case "sequence": {
+      let out = empty();
+      for (const term of d.parsers) {
+        out = union(out, fs2(term));
+        if (!matchesEmpty(term)) return out;
+      }
+      return out;
+    }
+    case "oneOrMore":
+    case "many":
+    case "optional":
+    case "transform":
+    case "label":
+    case "trivia":
+    case "node":
+    case "grammar":
+    case "expect":
+      return fs2(d.parser);
+    case "sepBy":
+      return fs2(d.parser);
+    case "skip":
+      return fs2(d.main);
+    default:
+      return p._meta.firstSet;
+  }
+}
 function mergeRanges(ranges) {
   if (ranges.length === 0) return [];
   const sorted = [...ranges].sort((a, b) => a.lo - b.lo);
@@ -333,12 +381,16 @@ function pushTriviaLogEntry(ctx, start, end, kindIndex) {
 }
 
 // src/combinators/literal.ts
-var _collatorCache = null;
-function collator() {
-  if (_collatorCache === null) {
-    _collatorCache = new Intl.Collator(void 0, { sensitivity: "accent" });
+function asciiFoldEq(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    let ca = a.charCodeAt(i);
+    let cb = b.charCodeAt(i);
+    if (ca >= 65 && ca <= 90) ca += 32;
+    if (cb >= 65 && cb <= 90) cb += 32;
+    if (ca !== cb) return false;
   }
-  return _collatorCache;
+  return true;
 }
 function literal(value, opts = {}) {
   const caseInsensitive = opts.caseInsensitive ?? false;
@@ -353,8 +405,9 @@ function literal(value, opts = {}) {
     const lower = value.toLowerCase();
     const firstUpper = upper.codePointAt(0);
     const firstLower = lower.codePointAt(0);
-    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? { kind: "ranges", ranges: [
-      { lo: Math.min(firstLower, firstUpper), hi: Math.max(firstLower, firstUpper) }
+    meta.firstSet = firstLower !== void 0 && firstUpper !== void 0 ? firstLower === firstUpper ? { kind: "ranges", ranges: [{ lo: firstLower, hi: firstLower }] } : { kind: "ranges", ranges: [
+      { lo: firstLower, hi: firstLower },
+      { lo: firstUpper, hi: firstUpper }
     ] } : firstSet;
   }
   return {
@@ -367,7 +420,7 @@ function literal(value, opts = {}) {
         return failAt(ctx, [JSON.stringify(value)], pos);
       }
       const slice = input.slice(pos, end);
-      const matched = caseInsensitive ? collator().compare(slice, value) === 0 : slice === value;
+      const matched = caseInsensitive ? asciiFoldEq(slice, value) : slice === value;
       if (matched) {
         const span = { start: pos, end };
         const leaf = { _tag: "leaf", value: slice, span };
@@ -1260,6 +1313,41 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// src/combinators/parser.ts
+function rules(factory) {
+  const cache = {};
+  const proxy = new Proxy(cache, {
+    get(target, key) {
+      if (typeof key !== "string") return void 0;
+      const record = target;
+      if (!(key in record)) {
+        const r = ref();
+        r._ruleName = key;
+        record[key] = r;
+      }
+      return record[key];
+    }
+  });
+  const definitions = factory(proxy);
+  for (const key of Object.keys(definitions)) {
+    const placeholder = cache[key];
+    const parser2 = definitions[key];
+    if (placeholder !== void 0 && typeof placeholder.define === "function") {
+      ;
+      placeholder.define(parser2);
+      placeholder._meta.firstSet = parser2._meta.firstSet;
+      placeholder._meta.canMatchNewline = parser2._meta.canMatchNewline;
+    } else {
+      ;
+      cache[key] = parser2;
+    }
+  }
+  for (const key of Object.keys(definitions)) {
+    markUnusedValues(cache[key]);
+  }
+  return cache;
+}
+
 // src/combinators/not.ts
 function not(combinator) {
   const meta = {
@@ -1366,6 +1454,20 @@ function transform(combinator, fn) {
     }
   };
 }
+function skip(main, skipped) {
+  return {
+    _tag: "skip",
+    _meta: main._meta,
+    _def: { tag: "skip", main, skipped },
+    parse(input, pos, ctx) {
+      const result = main.parse(input, pos, ctx);
+      if (!result.ok) return result;
+      const s = skipped.parse(input, result.span.end, ctx);
+      if (!s.ok) return result;
+      return { ...result, span: { start: result.span.start, end: s.span.end } };
+    }
+  };
+}
 function trivia(combinator) {
   const kindLabels = analyzeLabeledTrivia(combinator)?.labels;
   return {
@@ -1596,8 +1698,8 @@ function classToRanges(cls) {
   return parseClassRanges(body);
 }
 var foldEq = (cVar, cp) => {
-  if (cp >= 65 && cp <= 90) return `(${cVar} === ${cp} || ${cVar} === ${cp + 32})`;
-  if (cp >= 97 && cp <= 122) return `(${cVar} === ${cp} || ${cVar} === ${cp - 32})`;
+  if (cp >= 65 && cp <= 90) return `(${cVar} | 32) === ${cp + 32}`;
+  if (cp >= 97 && cp <= 122) return `(${cVar} | 32) === ${cp}`;
   return `${cVar} === ${cp}`;
 };
 function literalCodePoints(frag) {
@@ -1848,6 +1950,12 @@ function firstSetsDisjoint(a, b) {
   return classDisjoint(a, b);
 }
 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) {
@@ -2269,12 +2377,34 @@ function parseScanShapeCore(source) {
 }
 function scanShapeFromRegex(source, flags) {
   if (/[msu]/.test(flags)) return null;
-  if (/i/.test(flags)) {
-    const open = literalCodePoints(source);
-    return open ? { kind: "litFold", open } : null;
-  }
+  if (/i/.test(flags)) return caseFoldShape(source);
   return parseScanShape(source);
 }
+function caseFoldShape(source) {
+  const la = stripTrailingLookahead(source);
+  if (la) {
+    const inner = caseFoldLiteralOrAlt(la.base);
+    if (!inner) return null;
+    const operand = { ranges: la.ranges, negated: la.classNegated };
+    if (!lookaheadUnambiguous(inner, operand, la.negative)) return null;
+    return { kind: "lookahead", inner, ranges: la.ranges, classNegated: la.classNegated, negative: la.negative };
+  }
+  return caseFoldLiteralOrAlt(source);
+}
+function caseFoldLiteralOrAlt(source) {
+  const asciiOnly = (cps) => cps.every((cp) => cp <= 127);
+  const open = literalCodePoints(source);
+  if (open) return asciiOnly(open) ? { kind: "litFold", open } : null;
+  const arms = splitTopLevelAlternation(source);
+  if (!arms || arms.length < 2) return null;
+  const litArms = [];
+  for (const arm of arms) {
+    const cp = literalCodePoints(arm);
+    if (!cp || !asciiOnly(cp)) return null;
+    litArms.push({ kind: "litFold", open: cp });
+  }
+  return { kind: "alt", arms: litArms, disjoint: false, firsts: litArms.map(() => null) };
+}
 var classCond = (cVar, ranges) => ranges.map(([lo, hi]) => lo === hi ? `${cVar} === ${lo}` : `(${cVar} >= ${lo} && ${cVar} <= ${hi})`).join(" || ");
 var litCond = (base, cps, firstVar) => cps.map(
   (cp, k) => k === 0 && firstVar ? `${firstVar} === ${cp}` : `input.charCodeAt(${base}${k ? ` + ${k}` : ""}) === ${cp}`
@@ -2286,6 +2416,25 @@ function stringHardStop(shape) {
   );
 }
 var codeAt = (start, firstChar) => firstChar ?? `input.charCodeAt(${start})`;
+var ALT_SWITCH_RANGE_LIMIT = 4;
+var ALT_SWITCH_MAX_CASES = 48;
+var ALT_SWITCH_MIN_CASES = 3;
+function planAltSwitch(firsts) {
+  const cases = [];
+  let total = 0;
+  for (const fs2 of firsts) {
+    if (!fs2 || fs2.negated) return { kind: "if" };
+    const pts = [];
+    for (const [lo, hi] of fs2.ranges) {
+      if (hi - lo + 1 > ALT_SWITCH_RANGE_LIMIT) return { kind: "if" };
+      for (let cp = lo; cp <= hi; cp++) pts.push(cp);
+    }
+    total += pts.length;
+    if (total > ALT_SWITCH_MAX_CASES) return { kind: "if" };
+    cases.push(pts);
+  }
+  return total >= ALT_SWITCH_MIN_CASES ? { kind: "switch", cases } : { kind: "if" };
+}
 function emitShapeMatch(shape, start, mint, ind2, firstChar) {
   if (shape.kind === "lookahead") {
     const inner = emitShapeMatch(shape.inner, start, mint, ind2, firstChar);
@@ -2310,18 +2459,57 @@ function emitShapeMatch(shape, start, mint, ind2, firstChar) {
     const okV = mint("_ok");
     const endV2 = mint("_end");
     const lines = [`${ind2}let ${okV} = false`, `${ind2}let ${endV2} = ${start}`];
+    if (shape.arms.length >= 2 && shape.arms.every((a) => a.kind === "litFold" && a.open.length >= 1)) {
+      const groups = /* @__PURE__ */ new Map();
+      for (const a of shape.arms) {
+        const open = a.open;
+        const f = open[0];
+        const lower = f >= 65 && f <= 90 ? f + 32 : f;
+        (groups.get(lower) ?? groups.set(lower, []).get(lower)).push(open);
+      }
+      lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+      for (const [lower, arms] of groups) {
+        const labels = lower >= 97 && lower <= 122 ? `case ${lower}: case ${lower - 32}:` : `case ${lower}:`;
+        lines.push(`${ind2}  ${labels} {`);
+        for (const open of arms) {
+          const tail = open.slice(1).map((cp, i) => foldEq(`input.charCodeAt(${start} + ${i + 1})`, cp));
+          const cond = tail.length ? ` && ${tail.join(" && ")}` : "";
+          lines.push(`${ind2}    if (${start} + ${open.length} <= input.length${cond}) { ${okV} = true; ${endV2} = ${start} + ${open.length}; break }`);
+        }
+        lines.push(`${ind2}    break`);
+        lines.push(`${ind2}  }`);
+      }
+      lines.push(`${ind2}}`);
+      return { setup: lines, ok: okV, end: endV2 };
+    }
     if (shape.disjoint) {
-      const c0 = codeAt(start, firstChar);
-      shape.arms.forEach((arm, k) => {
-        const fs2 = shape.firsts[k];
-        const cond = fs2.negated ? `!(${classCond(c0, fs2.ranges)})` : `(${classCond(c0, fs2.ranges)})`;
-        const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
-        lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
-        lines.push(...m.setup);
-        lines.push(`${ind2}  ${okV} = ${m.ok}`);
-        lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+      const plan = planAltSwitch(shape.firsts);
+      if (plan.kind === "switch") {
+        lines.push(`${ind2}if (${start} < input.length) switch (${codeAt(start, firstChar)}) {`);
+        shape.arms.forEach((arm, k) => {
+          const labels = plan.cases[k].map((cp) => `case ${cp}:`).join(" ");
+          const m = emitShapeMatch(arm, start, mint, `${ind2}    `, firstChar);
+          lines.push(`${ind2}  ${labels} {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}    ${okV} = ${m.ok}`);
+          lines.push(`${ind2}    ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}    break`);
+          lines.push(`${ind2}  }`);
+        });
         lines.push(`${ind2}}`);
-      });
+      } else {
+        const c0 = codeAt(start, firstChar);
+        shape.arms.forEach((arm, k) => {
+          const fs2 = shape.firsts[k];
+          const cond = fs2.negated ? `!(${classCond(c0, fs2.ranges)})` : `(${classCond(c0, fs2.ranges)})`;
+          const m = emitShapeMatch(arm, start, mint, `${ind2}  `, firstChar);
+          lines.push(`${ind2}${k === 0 ? "if" : "else if"} (${start} < input.length && ${cond}) {`);
+          lines.push(...m.setup);
+          lines.push(`${ind2}  ${okV} = ${m.ok}`);
+          lines.push(`${ind2}  ${endV2} = ${m.ok} ? ${m.end} : ${start}`);
+          lines.push(`${ind2}}`);
+        });
+      }
     } else {
       const lbl = mint("_alt");
       lines.push(`${ind2}${lbl}: {`);
@@ -2809,6 +2997,16 @@ function tryInlineDestructureTransform(src, valueVars) {
 }
 
 // src/compiler/codegen.ts
+var HOST_READS_DECL = "const _hostReads = (b, n) => { if (b === undefined) return false; let s; try { s = Function.prototype.toString.call(b) } catch (e) { return true } if (/\\barguments\\b/.test(s)) return true; const m = /^[^(]*\\(([\\s\\S]*?)\\)/.exec(s); if (m && /\\.\\.\\.|=/.test(m[1])) return true; return b.length > n }";
+var _loweringSink = null;
+function beginLoweringCapture() {
+  _loweringSink = /* @__PURE__ */ new Set();
+}
+function endLoweringCapture() {
+  const misses = _loweringSink ? [..._loweringSink] : [];
+  _loweringSink = null;
+  return misses;
+}
 function v(ctx, prefix = "_v") {
   return `${prefix}${ctx.vars++}`;
 }
@@ -2898,16 +3096,12 @@ function namedFnPrelude() {
 function pushNamedFnDecl(ctx, fnName, bodyStmts, valueVar, endVar) {
   ctx.namedFnDecls.push([
     `function ${fnName}(input, _pos, _ctx) {`,
-    `  let _pfok = false, _pfv, _pfe = _pos`,
     `  _pfail: {`,
     ...reindentStmts(bodyStmts, 2),
-    `    _pfv = ${valueVar}`,
-    `    _pfe = ${endVar}`,
-    `    _pfok = true`,
+    `    ${NAMED_FN_END} = ${endVar}`,
+    `    return ${valueVar}`,
     `  }`,
-    `  if (!_pfok) return ${NAMED_FN_FAIL}`,
-    `  ${NAMED_FN_END} = _pfe`,
-    `  return _pfv`,
+    `  return ${NAMED_FN_FAIL}`,
     `}`
   ].join("\n"));
 }
@@ -3207,13 +3401,14 @@ function emitLit(def, ctx, pos) {
   const vv = v(ctx);
   const expectedStr = JSON.stringify(JSON.stringify(value));
   const stmts = [];
-  if (caseInsensitive) {
-    ctx.needsCollator = true;
+  if (caseInsensitive && len > 0) {
+    const match = Array.from(
+      { length: len },
+      (_, i) => `(${foldEq(`input.charCodeAt(${pos}${i > 0 ? ` + ${i}` : ""})`, value.charCodeAt(i))})`
+    ).join(" && ");
     stmts.push(
-      ...emitIfFail(ctx, `${pos} + ${len} > input.length`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv}_s = input.slice(${pos}, ${pos} + ${len})`,
-      ...emitIfFail(ctx, `_collator.compare(${vv}_s, ${JSON.stringify(value)}) !== 0`, failBody(ctx, expectedStr, pos)),
-      `${ind(ctx)}const ${vv} = ${vv}_s`
+      ...emitIfFail(ctx, `${pos} + ${len} > input.length || !(${match})`, failBody(ctx, expectedStr, pos)),
+      `${ind(ctx)}const ${vv} = input.slice(${pos}, ${pos} + ${len})`
     );
   } else if (len === 0) {
     stmts.push(`${ind(ctx)}const ${vv} = ''`);
@@ -3334,6 +3529,7 @@ function emitRegex(def, ctx, pos) {
       return { stmts: stmts2, valueVar: vv2, endVar: scanned.endVar };
     }
   }
+  _loweringSink?.add(`/${def.source}/${def.flags}`);
   const flags = "y" + def.flags.replace(/[gy]/g, "");
   const key = `${def.source}/${flags}`;
   let rName = ctx.regexMap.get(key);
@@ -3606,11 +3802,16 @@ function emitFirstMatch(def, ctx, pos) {
     const atStart = failsAtStart(p);
     const staticFx = armStaticExpected(ctx, p);
     const deferRuleName = ctx.deferFirstSetRefs ? p._ruleName : void 0;
-    const fsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : null;
+    const fsGuard = deferRuleName !== void 0 ? `/*@FS:${deferRuleName}:${codeV}@*/true` : needsFirstSetGuard(p) ? firstSetCond(codeV, p._meta.firstSet) : (() => {
+      if (p._meta.firstSet.kind !== "any" || matchesEmpty(p)) return null;
+      const deep = firstSetOf(p);
+      return deep.kind === "ranges" ? firstSetCond(codeV, deep) : null;
+    })();
     let gateCond = null;
     if (gate) {
       const gateIdx = ctx.mapFns.length;
       ctx.mapFns.push(gate);
+      ctx.mapFnSrcs.push(null);
       gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`;
     }
     const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`;
@@ -3669,13 +3870,21 @@ function emitNonDisjoint(def, strategy, allExpected, ctx, pos) {
     return emitLiteralsLongestFirst(def, strategy.sortedIndices, allExpected, ctx, pos);
   return emitFirstMatch(def, ctx, pos);
 }
+function pushMapFn(ctx, fn, src) {
+  if (src !== null && ctx.mapFns.length === ctx.mapFnSrcs.length) {
+    const hit = ctx.mapFnSrcs.indexOf(src);
+    if (hit !== -1) return hit;
+  }
+  const idx = ctx.mapFns.length;
+  ctx.mapFns.push(fn);
+  ctx.mapFnSrcs.push(src);
+  return idx;
+}
 function emitTransformChain(p, baseValue, endV, startPos, ctx) {
   const def = p._def;
   if (def.tag === "transform") {
     const innerR = emitTransformChain(def.parser, baseValue, endV, startPos, ctx);
-    const fnIdx = ctx.mapFns.length;
-    ctx.mapFns.push(def.fn);
-    ctx.mapFnSrcs.push(def.fnSrc ?? null);
+    const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null);
     const vv = v(ctx);
     return {
       stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = ${mfRef(ctx)}[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
@@ -3858,7 +4067,7 @@ function emitScanTo(def, ctx, pos) {
     `${ind(ctx)}while (${curV} < input.length) {`
   ];
   ctx.indent++;
-  const probeCtx = { ...ctx, capturing: false };
+  const probeCtx = { ...ctx, capturing: false, noHoist: true };
   const { stmts: sentStmts, okVar: sentOk } = emitFallible(def.sentinel, probeCtx, curV);
   stmts.push(...sentStmts, `${ind(ctx)}if (${sentOk}) { ${foundV} = true; break }`);
   if (def.skip.length > 0) {
@@ -3914,15 +4123,19 @@ function emitNode(def, ctx, pos) {
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || structural || buildReadsTrivia(def);
-  const clonesState = structural || buildReadsState(def);
+  const capturesTrivia = mkType !== null || !structural && buildReadsTrivia(def);
+  const clonesState = !structural && buildReadsState(def);
   const chV = v(ctx, "_ch");
   const rawV = v(ctx, "_raw");
-  const tlV = capturesTrivia ? v(ctx, "_tl") : "_EMPTY_TL";
+  const capTLv = structural ? v(ctx, "_ctl") : null;
+  const capSTv = structural ? v(ctx, "_cst") : null;
+  const tlV = capturesTrivia || structural ? v(ctx, "_tl") : "_EMPTY_TL";
   if (!capturesTrivia) ctx.needsEmptyTl = true;
   const sc = v(ctx, "_sc"), sl = v(ctx, "_sl"), sr = v(ctx, "_sr"), st = v(ctx, "_st"), stl = v(ctx, "_stl");
-  const allocStmt = capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
-  const innerTl = capturesTrivia ? tlV : "undefined";
+  if (structural) ctx.needsHostReads = true;
+  const allocStmt = structural ? `${i}const ${capTLv} = _ctx._pmCapTL ??= _hostReads(_ctx.build, 4), ${capSTv} = _ctx._pmCapST ??= (_ctx.build === undefined || _hostReads(_ctx.build, 5))
+${i}const ${chV} = [], ${rawV} = [], ${tlV} = ${capTLv} ? [] : _EMPTY_TL` : capturesTrivia ? `${i}const ${chV} = [], ${rawV} = [], ${tlV} = []` : `${i}const ${chV} = [], ${rawV} = []`;
+  const innerTl = structural ? `${capTLv} ? ${tlV} : undefined` : capturesTrivia ? tlV : "undefined";
   const stmts = [
     allocStmt,
     `${i}const ${sc} = _ctx._cstChildren, ${sl} = _ctx._cstLeaves, ${sr} = _ctx._cstRawChildren, ${st} = _ctx.captureTrivia, ${stl} = _ctx._cstTriviaLog`,
@@ -3933,7 +4146,10 @@ function emitNode(def, ctx, pos) {
   stmts.push(`${i}_ctx._cstChildren = ${sc}; _ctx._cstLeaves = ${sl}; _ctx._cstRawChildren = ${sr}; _ctx.captureTrivia = ${st}; _ctx._cstTriviaLog = ${stl}`);
   stmts.push(...emitIfFail(ctx, `!${okVar}`, propagateFailBody(ctx)));
   let stV = "undefined";
-  if (clonesState) {
+  if (structural) {
+    stV = v(ctx, "_nst");
+    stmts.push(`${i}const ${stV} = ${capSTv} && _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
+  } else if (clonesState) {
     stV = v(ctx, "_nst");
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
@@ -4042,6 +4258,32 @@ function emitExpect(def, ctx, pos) {
   return { stmts, valueVar: valVar, endVar };
 }
 function emit(p, ctx, pos) {
+  const usage = ctx.lazyUsage;
+  if (usage && !ctx.noHoist && !ctx.capAsTrivia && !ctx.ruleNames?.has(p) && isHoistableTag(p._def.tag) && (usage.counts.get(p) ?? 0) > 1 && // Only hoist subtrees big enough that de-duplicating them beats the call
+  // overhead. A tiny shared wrapper (e.g. `optional(literal(';'))`) inlines
+  // faster than it calls and barely moves the byte count; the size explosion
+  // is all in LARGE choices/sequences referenced from many positions.
+  (usage.sizes.get(p) ?? 0) >= HOIST_MIN_SUBTREE) {
+    const existing = ctx.namedParsers.get(p);
+    if (existing !== void 0) return emitNamedFnCall(ctx, existing, pos);
+    const fnName = `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
+    ctx.namedParsers.set(p, fnName);
+    const savedIndent = ctx.indent;
+    const savedFailLabel = ctx.failLabel;
+    const savedRecord = ctx.recordFail;
+    ctx.indent = 1;
+    ctx.failLabel = "_pfail";
+    ctx.recordFail = true;
+    const r = emitDispatch(p, ctx, "_pos");
+    ctx.indent = savedIndent;
+    ctx.failLabel = savedFailLabel;
+    ctx.recordFail = savedRecord;
+    pushNamedFnDecl(ctx, fnName, r.stmts, r.valueVar, r.endVar);
+    return emitNamedFnCall(ctx, fnName, pos);
+  }
+  return emitDispatch(p, ctx, pos);
+}
+function emitDispatch(p, ctx, pos) {
   const def = p._def;
   switch (def.tag) {
     case "literal":
@@ -4087,9 +4329,7 @@ function emit(p, ctx, pos) {
           };
         }
       }
-      const fnIdx = ctx.mapFns.length;
-      ctx.mapFns.push(def.fn);
-      ctx.mapFnSrcs.push(def.fnSrc ?? null);
+      const fnIdx = pushMapFn(ctx, def.fn, def.fnSrc ?? null);
       const mv = v(ctx, "_mapped");
       return {
         stmts: [
@@ -4154,6 +4394,7 @@ function emit(p, ctx, pos) {
     case "guard": {
       const fnIdx = ctx.mapFns.length;
       ctx.mapFns.push(def.predicate);
+      ctx.mapFnSrcs.push(null);
       const vv = v(ctx);
       return {
         stmts: [
@@ -4168,6 +4409,7 @@ function emit(p, ctx, pos) {
       const evIdx = ctx.mapFns.length;
       const extra = def.extra;
       ctx.mapFns.push((() => extra));
+      ctx.mapFnSrcs.push(null);
       const innerParser = def.parser;
       if (!ctx.namedParsers.has(innerParser)) {
         const fnName = `_wcf${ctx.namedParsers.size}`;
@@ -4287,9 +4529,58 @@ function childrenOf(def) {
       return [];
   }
 }
+var HOISTABLE_TAGS = /* @__PURE__ */ new Set([
+  "sequence",
+  "choice",
+  "many",
+  "oneOrMore",
+  "optional",
+  "sepBy",
+  "transform",
+  "node",
+  "not"
+]);
+function isHoistableTag(tag) {
+  return HOISTABLE_TAGS.has(tag);
+}
+var HOIST_MIN_SUBTREE = 3;
 function analyzeLazyUsage(root) {
   return analyzeLazyUsageMulti([root]);
 }
+function subtreeSizes(roots) {
+  const sizes = /* @__PURE__ */ new Map();
+  const sz = (p) => {
+    const cached = sizes.get(p);
+    if (cached !== void 0) return cached;
+    const def = p._def;
+    let s = 1;
+    if (def.tag !== "lazy") {
+      for (const child of childrenOf(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
+    }
+    sizes.set(p, s);
+    return s;
+  };
+  const visitedLazy = /* @__PURE__ */ new Set();
+  const visit = (p) => {
+    const def = p._def;
+    if (def.tag === "lazy") {
+      if (visitedLazy.has(p)) return;
+      visitedLazy.add(p);
+      let resolved;
+      try {
+        resolved = def.thunk();
+      } catch {
+        return;
+      }
+      visit(resolved);
+      return;
+    }
+    sz(p);
+    for (const child of childrenOf(def)) visit(child);
+  };
+  for (const root of roots) visit(root);
+  return sizes;
+}
 function analyzeLazyUsageMulti(roots) {
   const counts = /* @__PURE__ */ new Map();
   const recursive = /* @__PURE__ */ new Set();
@@ -4316,10 +4607,14 @@ function analyzeLazyUsageMulti(roots) {
       active.delete(p);
       return;
     }
+    if (isHoistableTag(def.tag)) {
+      counts.set(p, (counts.get(p) ?? 0) + 1);
+    }
     for (const child of childrenOf(def)) walk2(child);
   }
-  for (const root of roots) walk2(root);
-  return { counts, recursive };
+  const rootsArr = [...roots];
+  for (const root of rootsArr) walk2(root);
+  return { counts, recursive, sizes: subtreeSizes(rootsArr) };
 }
 function ruleDependencies(ruleMap) {
   const nameOf = /* @__PURE__ */ new Map();
@@ -4369,7 +4664,6 @@ function compile(combinator, mapFnSources) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4378,18 +4672,18 @@ function compile(combinator, mapFnSources) {
     lazyUsage: analyzeLazyUsage(combinator)
   };
   const r = emit(combinator, ctx, "_pos");
-  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
-` : "";
   const namedPrelude = ctx.namedFnDecls.length > 0 ? [...namedFnPrelude(), ""] : [];
   const emptyTlDecls = ctx.needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [];
+  const hostReadsDecls = ctx.needsHostReads ? [HOST_READS_DECL] : [];
   const source = [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     "",
     ...namedPrelude,
     ctx.namedFnDecls.join("\n\n"),
-    `${collatorDecl}function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
+    `function _parse(input, _pos, _rp, _mf, _build, _ctx) {`,
     `  let pos = _pos`,
     ...r.stmts,
     `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
@@ -4397,9 +4691,9 @@ function compile(combinator, mapFnSources) {
   ].join("\n");
   const fn = new Function("input", "_pos", "_rp", "_mf", "_build", "_ctx", [
     ...emptyTlDecls,
+    ...hostReadsDecls,
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
-    collatorDecl,
     ...namedPrelude,
     ...ctx.namedFnDecls.flatMap((decl, i) => i > 0 ? ["", decl] : [decl]),
     `let pos = _pos`,
@@ -4416,7 +4710,7 @@ function compile(combinator, mapFnSources) {
   const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
   const mfCovered = ctx.mapFns.length === 0 || effectiveSources !== void 0 && effectiveSources.length === ctx.mapFns.length;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
-  const inlineExpression = canInline ? buildInlineExpression(ctx, r, collatorDecl, effectiveSources, buildSources) : null;
+  const inlineExpression = canInline ? buildInlineExpression(ctx, r, effectiveSources, buildSources) : null;
   return {
     source,
     inlineExpression,
@@ -4461,7 +4755,6 @@ function compileRuleMap(ruleMap) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4480,8 +4773,6 @@ function compileRuleMap(ruleMap) {
   }
   ctx.ruleNames = ruleNames;
   const perEntry = ruleMap.map(([key, rule]) => ({ key, r: emit(rule, ctx, "_pos") }));
-  const collatorDecl = ctx.needsCollator ? `const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })
-` : "";
   const derivedSrcs = ctx.mapFnSrcs.length === ctx.mapFns.length && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : void 0;
   const buildCovered = ctx.buildFns.length === 0 || ctx.buildSrcs.every((s) => s !== null);
   const buildSources = ctx.buildFns.length === 0 ? void 0 : ctx.buildSrcs;
@@ -4493,9 +4784,9 @@ function compileRuleMap(ruleMap) {
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
+    ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "",
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
-    collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
     ...namedPrelude.map((l) => `  ${l}`),
@@ -4548,7 +4839,6 @@ function compileLinkable(ruleMapArg, ns) {
     buildFns: [],
     buildSrcs: [],
     runtimeParsers: [],
-    needsCollator: false,
     namedParsers: /* @__PURE__ */ new Map(),
     triviaCaptureNames: /* @__PURE__ */ new Map(),
     triviaFnNames: /* @__PURE__ */ new Map(),
@@ -4679,12 +4969,12 @@ function compileLinkable(ruleMapArg, ns) {
     firstSets,
     deps: ruleDependencies(ruleMap),
     needsEmptyTl: !!ctx.needsEmptyTl,
-    needsCollator: ctx.needsCollator,
+    needsHostReads: !!ctx.needsHostReads,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
 }
-function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
+function buildInlineExpression(ctx, r, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
     ...r.stmts,
@@ -4698,14 +4988,15 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   const mfDecl = mapFnSources?.length ? `  const _mf = [${mapFnSources.join(", ")}]` : "";
   const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
   const emptyTlDecl = ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "";
-  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || !!collatorDecl || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl;
+  const hostReadsDecl = ctx.needsHostReads ? `  ${HOST_READS_DECL}` : "";
+  const needsWrapper = ctx.regexDecls.length > 0 || ctx.expectedDecls.length > 0 || ctx.namedFnDecls.length > 0 || !!mfDecl || !!buildDecl || !!emptyTlDecl || !!hostReadsDecl;
   if (!needsWrapper) return innerFn;
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     emptyTlDecl,
+    hostReadsDecl,
     ...ctx.regexDecls.map((d) => `  ${d}`),
     ...ctx.expectedDecls.map((d) => `  ${d}`),
-    collatorDecl ? `  ${collatorDecl.trim()}` : "",
     mfDecl,
     buildDecl,
     ...namedPrelude.map((l) => `  ${l}`),
@@ -4722,64 +5013,6 @@ function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources)
   ].join("\n");
 }
 
-// src/compiler/linker.ts
-function fusedBody(pieces) {
-  const winner = /* @__PURE__ */ new Map();
-  for (const p of pieces) for (const k of p.keys) winner.set(k, p);
-  for (const [k, p] of winner) {
-    for (const d of p.deps.get(k) ?? []) {
-      if (!winner.has(d)) throw new Error(`compose: rule "${k}" references missing rule "${d}"`);
-    }
-  }
-  const contributing = new Set(winner.values());
-  const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
-  const needsCollator = [...contributing].some((p) => p.needsCollator);
-  const lines = [
-    // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
-    "const _pfFail = {}",
-    "let _pfEnd",
-    ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
-    ...needsCollator ? ["const _collator = new Intl.Collator(undefined, { sensitivity: 'accent' })"] : [],
-    // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
-    ...[...contributing].flatMap((p) => p.prelude),
-    // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
-    ...[...winner].map(([k, p]) => p.ruleFns.get(k))
-  ];
-  const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
-  const rawBody = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
-  const finalFS = /* @__PURE__ */ new Map();
-  for (const [k, p] of winner) {
-    const fs2 = p.firstSets?.get(k);
-    if (fs2) finalFS.set(k, fs2);
-  }
-  const body = rawBody.replace(
-    // Rule name + code-point var are both JS identifiers (rule names are validated
-    // at compile time — see assertRuleName in codegen), so an identifier class
-    // matches every well-formed placeholder.
-    /\/\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\*\/true/g,
-    (_m, name, codevar) => {
-      const fs2 = finalFS.get(name);
-      if (!fs2 || fs2.kind === "any" || fs2.kind === "empty") return "true";
-      return `(${firstSetCond(codevar, fs2)})`;
-    }
-  );
-  const env = {};
-  for (const p of contributing) {
-    if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
-    if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns;
-  }
-  return { body, env };
-}
-function emitFusedSource(pieces) {
-  const { body, env } = fusedBody(pieces);
-  if (Object.keys(env).length > 0) {
-    throw new Error("emitFusedSource: artifact carries non-static callbacks (runtime-only); cannot emit static source");
-  }
-  return `/* @__PURE__ */ (() => {
-${body}
-})()`;
-}
-
 // src/combinators/scanTo.ts
 function scanTo(sentinel, { skip: skip2 = [], orEOF = false } = {}) {
   const meta = {
@@ -4874,6 +5107,354 @@ function escapeClassChar(ch) {
   return ch.replace(/[\\\]^-]/g, "\\$&");
 }
 
+// src/compiler/ir-serialize.ts
+function childrenOf2(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "transform":
+    case "trivia":
+    case "label":
+    case "not":
+    case "node":
+    case "expect":
+      return [def.parser];
+    case "grammar":
+      return def.triviaParser ? [def.parser, def.triviaParser] : [def.parser];
+    case "sepBy":
+      return [def.parser, def.separator];
+    case "skip":
+      return [def.main, def.skipped];
+    case "scanTo":
+      return [def.sentinel, ...def.skip];
+    case "lazy":
+    case "literal":
+    case "regex":
+    case "keywords":
+    case "guard":
+    case "withCtx":
+    case "recover":
+    case "unknown":
+      return [];
+  }
+}
+var ruleNameOf = (c) => c._ruleName;
+function lazyTarget(c) {
+  if (c._def.tag !== "lazy") return null;
+  try {
+    return c._def.thunk();
+  } catch {
+    return null;
+  }
+}
+var Unserializable = class extends Error {
+};
+function serializeRuleMap(ruleMap) {
+  try {
+    return new Serializer(ruleMap).run();
+  } catch (e) {
+    if (e instanceof Unserializable) {
+      if (process.env.PARSEMAN_IR_DEBUG) console.error(`[ir] fallback: ${e.message}`);
+      return null;
+    }
+    throw e;
+  }
+}
+function evalRuleMapIR(ir) {
+  const _tf = (child, src) => {
+    let fn2;
+    try {
+      fn2 = (0, eval)(`(${src})`);
+    } catch {
+      fn2 = () => {
+        throw new Error("IR transform fn not materialized");
+      };
+    }
+    const t = transform(child, fn2);
+    t._def.fnSrc = src;
+    return t;
+  };
+  const _nd = (type, child, src, opts) => {
+    const n = node(type, child, void 0, opts);
+    n._def.buildSrc = src;
+    return n;
+  };
+  const fn = new Function(
+    "rules",
+    "ref",
+    "regex",
+    "literal",
+    "keywords",
+    "sequence",
+    "choice",
+    "many",
+    "oneOrMore",
+    "optional",
+    "sepBy",
+    "not",
+    "node",
+    "parser",
+    "scanTo",
+    "transform",
+    "skip",
+    "trivia",
+    "label",
+    "expect",
+    "_tf",
+    "_nd",
+    `return (${ir})`
+  );
+  const map = fn(
+    rules,
+    ref,
+    regex,
+    literal,
+    keywords,
+    sequence,
+    choice,
+    many,
+    oneOrMore,
+    optional,
+    sepBy,
+    not,
+    node,
+    parser,
+    scanTo,
+    transform,
+    skip,
+    trivia,
+    label,
+    expect,
+    _tf,
+    _nd
+  );
+  return Object.entries(map);
+}
+var Serializer = class {
+  counts = /* @__PURE__ */ new Map();
+  selfRef = /* @__PURE__ */ new Set();
+  // combinators reached by an unnamed lazy pointing back into their own subtree
+  constName = /* @__PURE__ */ new Map();
+  emitted = /* @__PURE__ */ new Set();
+  decls = [];
+  ruleValues = /* @__PURE__ */ new Set();
+  ruleMap;
+  constructor(ruleMap) {
+    this.ruleMap = ruleMap;
+    for (const [, c] of ruleMap) this.ruleValues.add(this.body(c));
+  }
+  /** A `rules()` map wraps each rule value in a named `lazy` proxy; the real body is
+   * its target (compileLinkable unwraps the same way). A ref INSIDE a body stays a
+   * `g[name]` ref — only the top-level entry is unwrapped. */
+  body(c) {
+    return c._def.tag === "lazy" && ruleNameOf(c) !== void 0 ? lazyTarget(c) ?? c : c;
+  }
+  run() {
+    for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
+    let n = 0;
+    for (const [c, count] of this.counts) {
+      if (this.ruleValues.has(c)) continue;
+      if (count >= 2 || this.selfRef.has(c)) this.constName.set(c, `_s${n++}`);
+    }
+    const body = this.ruleMap.map(([name, c]) => `  ${JSON.stringify(name)}: ${this.wrap(this.body(c))}`).join(",\n");
+    if (this.decls.length === 0) return `rules((g) => ({
+${body}
+}))`;
+    return `rules((g) => {
+${this.decls.map((d) => "  " + d).join("\n")}
+  return ({
+${body}
+})
+})`;
+  }
+  /** Count identity references and flag self-referential subtrees. `active` is the
+   * set of combinators on the current DFS path (to detect a lazy pointing back). */
+  analyze(c, active) {
+    const def = c._def;
+    if (def.tag === "lazy") {
+      if (ruleNameOf(c) !== void 0) return;
+      const target = lazyTarget(c);
+      if (!target) throw new Unserializable("unresolved unnamed ref");
+      if (active.has(target)) {
+        this.selfRef.add(target);
+        return;
+      }
+      this.analyze(target, active);
+      return;
+    }
+    if (def.tag === "guard" || def.tag === "withCtx" || def.tag === "recover" || def.tag === "unknown") {
+      throw new Unserializable(`unsupported tag ${def.tag}`);
+    }
+    this.counts.set(c, (this.counts.get(c) ?? 0) + 1);
+    if ((this.counts.get(c) ?? 0) > 1) return;
+    active.add(c);
+    for (const child of childrenOf2(def)) this.analyze(child, active);
+    active.delete(c);
+  }
+  /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
+   * `selfOf` is the const currently being wrapped in a ref()/define closure — an
+   * unnamed lazy back into it emits the local ref var instead of recursing. */
+  ref(c, selfOf) {
+    const cn = this.constName.get(c);
+    if (cn) {
+      this.emitDecl(c);
+      return cn;
+    }
+    return this.expr(c, selfOf);
+  }
+  emitDecl(c) {
+    const name = this.constName.get(c);
+    if (this.emitted.has(name)) return;
+    this.emitted.add(name);
+    this.decls.push(`const ${name} = ${this.wrap(c)}`);
+  }
+  selfN = 0;
+  /** Emit `c`'s own constructor call, wrapping it in a `ref()`+`.define()` closure
+   * if it is self-referential (an unnamed lazy in its subtree points back to it) —
+   * the shape `balanced()` and other recursive library combinators build. */
+  wrap(c) {
+    if (!this.selfRef.has(c)) return this.expr(c, null);
+    const rv = `_rr${this.selfN++}`;
+    const bodyExpr = this.expr(c, { comb: c, var: rv });
+    return `(() => { const ${rv} = ref(); const _b = ${bodyExpr}; ${rv}.define(_b); return _b })()`;
+  }
+  /** Emit the constructor-call source for `c` (never a const shortcut for `c` itself). */
+  expr(c, selfOf) {
+    const def = c._def;
+    const kid = (x) => this.ref(x, selfOf);
+    switch (def.tag) {
+      case "lazy": {
+        if (ruleNameOf(c) !== void 0) return `g[${JSON.stringify(ruleNameOf(c))}]`;
+        const target = lazyTarget(c);
+        if (selfOf && target === selfOf.comb) return selfOf.var;
+        return this.ref(target, selfOf);
+      }
+      case "literal":
+        return `literal(${JSON.stringify(def.value)}${def.caseInsensitive ? ", { caseInsensitive: true }" : ""})`;
+      case "regex":
+        return `regex(${JSON.stringify(def.source)}, ${JSON.stringify(def.flags)})`;
+      case "keywords":
+        return `keywords(${JSON.stringify(def.words)}, { caseInsensitive: ${def.caseInsensitive}${def.boundary !== void 0 ? `, boundary: ${JSON.stringify(def.boundary)}` : ""} })`;
+      case "sequence":
+        return `sequence(${def.parsers.map(kid).join(", ")})`;
+      case "choice": {
+        if (def.gates.some((g) => g !== null)) throw new Unserializable("choice with a gate() has no source");
+        return `choice(${def.parsers.map(kid).join(", ")})`;
+      }
+      case "many":
+        return `many(${kid(def.parser)})`;
+      case "oneOrMore":
+        return `oneOrMore(${kid(def.parser)})`;
+      case "optional":
+        return `optional(${kid(def.parser)})`;
+      case "sepBy":
+        return `sepBy(${kid(def.parser)}, ${kid(def.separator)})`;
+      case "not":
+        return `not(${kid(def.parser)})`;
+      case "trivia":
+        return `trivia(${kid(def.parser)})`;
+      case "label":
+        return `label(${JSON.stringify(def.label)}, ${kid(def.parser)})`;
+      case "expect":
+        return `expect(${kid(def.parser)}${def.label !== void 0 ? `, ${JSON.stringify(def.label)}` : ""})`;
+      case "skip":
+        return `skip(${kid(def.main)}, ${kid(def.skipped)})`;
+      case "scanTo":
+        return `scanTo(${kid(def.sentinel)}, { skip: [${def.skip.map(kid).join(", ")}], orEOF: ${def.orEOF} })`;
+      case "transform": {
+        if (def.fnSrc === void 0) throw new Unserializable("transform without fnSrc");
+        return `_tf(${kid(def.parser)}, ${JSON.stringify(def.fnSrc)})`;
+      }
+      case "node": {
+        if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
+        const opts = def.collapse ? `, { collapse: true }` : "";
+        if (def.buildSrc !== void 0) return `_nd(${JSON.stringify(def.type)}, ${kid(def.parser)}, ${JSON.stringify(def.buildSrc)}${opts})`;
+        return opts ? `node(${JSON.stringify(def.type)}, ${kid(def.parser)}, undefined${opts})` : `node(${JSON.stringify(def.type)}, ${kid(def.parser)})`;
+      }
+      case "grammar": {
+        const trivia2 = def.clearTrivia ? "null" : def.triviaParser ? kid(def.triviaParser) : "undefined";
+        return `parser({ trivia: ${trivia2}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
+      }
+      case "guard":
+      case "withCtx":
+      case "recover":
+      case "unknown":
+        throw new Unserializable(`unsupported tag ${def.tag}`);
+    }
+  }
+};
+
+// src/compiler/linker.ts
+function fusedBody(pieces) {
+  const winner = /* @__PURE__ */ new Map();
+  for (const p of pieces) for (const k of p.keys) winner.set(k, p);
+  for (const [k, p] of winner) {
+    for (const d of p.deps.get(k) ?? []) {
+      if (!winner.has(d)) throw new Error(`compose: rule "${k}" references missing rule "${d}"`);
+    }
+  }
+  const contributing = new Set(winner.values());
+  const needsEmptyTl = [...contributing].some((p) => p.needsEmptyTl);
+  const needsHostReads = [...contributing].some((p) => p.needsHostReads);
+  const lines = [
+    // Shared sentinel protocol (must match NAMED_FN_FAIL / NAMED_FN_END in codegen).
+    "const _pfFail = {}",
+    "let _pfEnd",
+    ...needsEmptyTl ? ["const _EMPTY_TL = Object.freeze([])"] : [],
+    ...needsHostReads ? [HOST_READS_DECL] : [],
+    // Each contributing artifact's namespaced private prelude (regexes, _pf, …).
+    ...[...contributing].flatMap((p) => p.prelude),
+    // The winning `_r_<Name>` function for each rule (one per name → no redeclare).
+    ...[...winner].map(([k, p]) => p.ruleFns.get(k))
+  ];
+  const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
+  const rawBody = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  const finalFS = /* @__PURE__ */ new Map();
+  for (const [k, p] of winner) {
+    const fs2 = p.firstSets?.get(k);
+    if (fs2) finalFS.set(k, fs2);
+  }
+  const body = rawBody.replace(
+    // Rule name + code-point var are both JS identifiers (rule names are validated
+    // at compile time — see assertRuleName in codegen), so an identifier class
+    // matches every well-formed placeholder.
+    /\/\*@FS:([A-Za-z0-9_$]+):([A-Za-z0-9_$]+)@\*\/true/g,
+    (_m, name, codevar) => {
+      const fs2 = finalFS.get(name);
+      if (!fs2 || fs2.kind === "any" || fs2.kind === "empty") return "true";
+      return `(${firstSetCond(codevar, fs2)})`;
+    }
+  );
+  const env = {};
+  for (const p of contributing) {
+    if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
+    if (p.buildFns.length) env[`${p.ns}build`] = p.buildFns;
+  }
+  return { body, env };
+}
+function emitFusedSource(pieces) {
+  const { body, env } = fusedBody(pieces);
+  if (Object.keys(env).length > 0) {
+    throw new Error("emitFusedSource: artifact carries non-static callbacks (runtime-only); cannot emit static source");
+  }
+  return `/* @__PURE__ */ (() => {
+${body}
+})()`;
+}
+function isIRPiece(p) {
+  return !!p && typeof p === "object" && typeof p.ir === "string" && typeof p.ns === "string" && !("ruleFns" in p);
+}
+function materializePiece(p) {
+  if (!isIRPiece(p)) return p;
+  const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns);
+  if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
+  return pieces;
+}
+
 // src/cst/offset-model.ts
 var { isFinite } = Number;
 
@@ -5385,7 +5966,7 @@ var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
     if (!code.includes("parseman")) return null;
     if (!code.includes("macro")) return null;
     const moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE, ...opts.moduleAliases ?? []]);
-    const result = transformMacro(code, id, moduleAliases);
+    const result = transformMacro(code, id, moduleAliases, opts.warnUnloweredRegex === true);
     if (result?.warnings.length) {
       for (const w of result.warnings) {
         if (typeof this?.warn === "function") this.warn(`[parseman] ${w}`);
@@ -5447,6 +6028,14 @@ function findCarriedPiecesLiteral(root) {
       const obj = callee?.object?.name;
       const prop = callee?.property?.name;
       const args = node2.arguments;
+      if (obj === "Object" && prop === "assign" && args && args[1]?.type === "ObjectExpression") {
+        for (const p of args[1].properties ?? []) {
+          if (p.computed && isComposedPiecesSymbol(p.key) && p.value) {
+            found = { start: p.value.start, end: p.value.end };
+            return;
+          }
+        }
+      }
       if (obj === "Object" && prop === "defineProperty" && args && isComposedPiecesSymbol(args[1])) {
         const descriptor = args[2];
         for (const p of descriptor?.properties ?? []) {
@@ -5467,7 +6056,21 @@ function findCarriedPiecesLiteral(root) {
   visit(root);
   return found;
 }
-function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE])) {
+function extractImportBindings(body) {
+  const out = /* @__PURE__ */ new Map();
+  for (const stmt of body) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const s = stmt;
+    for (const spec of s.specifiers) {
+      if (spec.type === "ImportSpecifier") {
+        const imported = spec.imported.name ?? spec.local.name;
+        out.set(spec.local.name, { source: s.source.value, imported });
+      }
+    }
+  }
+  return out;
+}
+function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE]), warnUnloweredRegex = false) {
   let result;
   try {
     result = (0, import_oxc_parser.parseSync)(id, code);
@@ -5506,6 +6109,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const scope = /* @__PURE__ */ new Map();
   const replacements = [];
   const warnings = [];
+  beginLoweringCapture();
   let anyUnresolved = false;
   let ruleMapHolderCounter = 0;
   const lineOf = (pos) => {
@@ -5540,14 +6144,57 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const isComposeCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "compose";
   const localRuleMaps = /* @__PURE__ */ new Map();
   const nsFor = (label2) => `_${(0, import_node_crypto.createHash)("sha1").update(`${id}#${label2}`).digest("hex").slice(0, 8)}_`;
+  const stripIndent = (s) => s.replace(/\n[ \t]+/g, "\n");
   const serializePieces = (p) => {
-    const mapLit = (m) => `new Map([${[...m].map(([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(v2)}]`).join(", ")}])`;
-    return `{ ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude)}, ruleFns: ${mapLit(p.ruleFns)}, wrappers: ${mapLit(p.wrappers)}, firstSets: ${mapLit(p.firstSets)}, deps: ${mapLit(p.deps)}, needsEmptyTl: ${p.needsEmptyTl}, needsCollator: ${p.needsCollator}, mfFns: [], buildFns: [] }`;
+    const mapLit = (m, stripVals = false) => `new Map([${[...m].map(
+      ([k, v2]) => `[${JSON.stringify(k)}, ${JSON.stringify(stripVals && typeof v2 === "string" ? stripIndent(v2) : v2)}]`
+    ).join(", ")}])`;
+    return `{ ns: ${JSON.stringify(p.ns)}, keys: ${JSON.stringify(p.keys)}, prelude: ${JSON.stringify(p.prelude.map(stripIndent))}, ruleFns: ${mapLit(p.ruleFns, true)}, wrappers: ${mapLit(p.wrappers, true)}, firstSets: ${mapLit(p.firstSets)}, deps: ${mapLit(p.deps)}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, mfFns: [], buildFns: [] }`;
   };
-  const serializeList = (list) => `[${list.map(serializePieces).join(", ")}]`;
-  const withCarriedPieces = (grammarExpr, list) => `/* @__PURE__ */ (() => { const _g = ${grammarExpr}; Object.defineProperty(_g, Symbol.for('parseman.composedPieces'), { value: ${serializeList(list)} }); return _g })()`;
+  const isSpread = (it) => "__spreadLocal" in it;
+  const isIR = (it) => "ir" in it && !("ruleFns" in it);
+  const serializeItem = (it) => isSpread(it) ? `...(${it.__spreadLocal}[Symbol.for('parseman.composedPieces')] ?? [])` : isIR(it) ? `{ ns: ${JSON.stringify(it.ns)}, ir: ${JSON.stringify(it.ir)} }` : serializePieces(it);
+  const serializeList = (list) => `[${list.map(serializeItem).join(", ")}]`;
+  const withCarriedPieces = (grammarExpr, list) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.composedPieces'), { value: ${serializeList(list)}, enumerable: false })`;
   const localComposedPieces = /* @__PURE__ */ new Map();
   const importedPiecesCache = /* @__PURE__ */ new Map();
+  const resolveModulePieces = (file, exportName, seen) => {
+    const mod = parseModuleCached(file);
+    if (!mod) return null;
+    const localFor = exportLocalName(mod.body, exportName);
+    const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
+    const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
+    if (!literalRange) return null;
+    const literal2 = mod.src.slice(literalRange.start, literalRange.end);
+    const imports = extractImportBindings(mod.body);
+    const stubNames = [];
+    const stubVals = [];
+    const spreadRe = /\.\.\.\s*\(?\s*([A-Za-z_$][\w$]*)\s*\[\s*Symbol\s*\.\s*for\s*\(\s*['"]parseman\.composedPieces['"]/g;
+    const done = /* @__PURE__ */ new Set();
+    for (let m; m = spreadRe.exec(literal2); ) {
+      const local = m[1];
+      if (done.has(local)) continue;
+      done.add(local);
+      const b = imports.get(local);
+      let subPieces = [];
+      if (b) {
+        let subFile = null;
+        try {
+          subFile = getCompiledResolver().resolveFileSync(file, b.source).path ?? null;
+        } catch {
+        }
+        if (subFile && !seen.has(subFile)) subPieces = resolveModulePieces(subFile, b.imported, new Set(seen).add(subFile)) ?? [];
+      }
+      stubNames.push(local);
+      stubVals.push({ [/* @__PURE__ */ Symbol.for("parseman.composedPieces")]: subPieces });
+    }
+    try {
+      const list = new Function(...stubNames, `return (${literal2})`)(...stubVals);
+      return list.map(materializePiece);
+    } catch {
+      return null;
+    }
+  };
   const importedPieces = (localName) => {
     if (importedPiecesCache.has(localName)) return importedPiecesCache.get(localName);
     let result2 = null;
@@ -5558,41 +6205,34 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         file = getCompiledResolver().resolveFileSync(id, binding.source).path ?? null;
       } catch {
       }
-      const mod = file ? parseModuleCached(file) : null;
-      if (mod) {
-        const localFor = exportLocalName(mod.body, binding.imported);
-        const initNode = localFor ? topLevelInit(mod.body, localFor) : null;
-        const literalRange = initNode ? findCarriedPiecesLiteral(initNode) : null;
-        if (literalRange) {
-          const literal2 = mod.src.slice(literalRange.start, literalRange.end);
-          try {
-            result2 = new Function(`return (${literal2})`)();
-          } catch {
-            result2 = null;
-          }
-        }
-      }
+      result2 = file ? resolveModulePieces(file, binding.imported, /* @__PURE__ */ new Set([file])) : null;
     }
     importedPiecesCache.set(localName, result2);
     return result2;
   };
+  const localArg = (rm, label2) => {
+    const entries = [...rm];
+    const ns = nsFor(label2);
+    const p = compileLinkable(entries, ns);
+    if (!p) return null;
+    const ir = serializeRuleMap(entries);
+    return ir ? { pieces: [p], ir: { ns, ir } } : { pieces: [p] };
+  };
   const argPieces = (arg, label2) => {
     if (isRulesCall(arg)) {
       const factory = arg.arguments[0];
       const rm = factory ? evaluateParserFactory(factory, scope, code, []) : null;
-      const p = rm ? compileLinkable([...rm], nsFor(label2)) : null;
-      return p ? [p] : null;
+      return rm ? localArg(rm, label2) : null;
     }
     if (arg.type === "Identifier") {
       const name = arg.name;
       const rm = localRuleMaps.get(name);
-      if (rm) {
-        const p = compileLinkable([...rm], nsFor(label2));
-        return p ? [p] : null;
-      }
+      if (rm) return localArg(rm, label2);
       const composed = localComposedPieces.get(name);
-      if (composed) return composed;
-      return importedPieces(name);
+      if (composed) return { pieces: composed };
+      const pieces = importedPieces(name);
+      if (!pieces) return null;
+      return importBindings.has(name) ? { pieces, spreadLocal: name } : { pieces };
     }
     return null;
   };
@@ -5605,16 +6245,20 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     const elements = arr.elements;
     const pieces = [];
+    const carried = [];
     for (let i = 0; i < elements.length; i++) {
-      const list = argPieces(elements[i], `compose${init.start}_${i}`);
-      if (!list) {
+      const r = argPieces(elements[i], `compose${init.start}_${i}`);
+      if (!r) {
         warn(init.start, `compose(): argument ${i} isn't a build-resolvable grammar; falling back to runtime`);
         return null;
       }
-      pieces.push(...list);
+      pieces.push(...r.pieces);
+      if (r.spreadLocal) carried.push({ __spreadLocal: r.spreadLocal });
+      else if (r.ir) carried.push(r.ir);
+      else carried.push(...r.pieces);
     }
     try {
-      return { replacement: emitFusedSource(pieces), pieces };
+      return { replacement: emitFusedSource(pieces), pieces, carried };
     } catch (e) {
       warn(init.start, `compose(): ${e.message}; falling back to runtime`);
       return null;
@@ -5701,9 +6345,11 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           localRuleMaps.set(varName, compiledRules.ruleMap);
           let replacement = compiledRules.replacement;
           if (exportPrefix) {
-            const pieces = compileLinkable([...compiledRules.ruleMap], nsFor(varName));
+            const ns = nsFor(varName);
+            const pieces = compileLinkable([...compiledRules.ruleMap], ns);
             if (pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
-              replacement = withCarriedPieces(replacement, [pieces]);
+              const ir = serializeRuleMap([...compiledRules.ruleMap]);
+              replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
             }
           }
           replacements.push({ start: init.start, end: init.end, replacement });
@@ -5713,7 +6359,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const fused = compileComposeCall(init);
           if (!fused) continue;
           localComposedPieces.set(varName, fused.pieces);
-          const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.pieces) : fused.replacement;
+          const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.carried) : fused.replacement;
           replacements.push({ start: init.start, end: init.end, replacement });
           continue;
         }
@@ -5813,6 +6459,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   for (const { start, end, replacement } of [...replacements].sort((a, b) => b.start - a.start)) {
     ms.overwrite(start, end, replacement);
   }
+  const unlowered = endLoweringCapture();
+  if (warnUnloweredRegex) {
+    for (const src of unlowered) {
+      warnings.push(`${id}: regex ${src} did not lower to a fast charCodeAt scan (RegExp.exec fallback)`);
+    }
+  }
   return {
     code: ms.toString(),
     map: ms.generateMap({ hires: true }),