parseman 0.13.0 → 0.14.0

package/dist/plugin/index.cjs

@@ -323,6 +323,36 @@ function literal(value, opts = {}) {
 }
 
 // src/combinators/regex.ts
+var firstSetAnalyzer = null;
+function registerRegexAnalyzer(analyzer) {
+  firstSetAnalyzer = analyzer;
+}
+var permissiveFirstSet = () => ({ firstSet: any(), canMatchNewline: true });
+function regex(pattern, flags = "") {
+  const source = typeof pattern === "string" ? pattern : pattern.source;
+  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
+  const anchored = new RegExp(source, "y" + resolvedFlags.replace(/[gy]/g, ""));
+  const { firstSet, canMatchNewline } = (firstSetAnalyzer ?? permissiveFirstSet)(source);
+  const meta = { firstSet, canMatchNewline, isTrivia: false };
+  return {
+    _tag: "regex",
+    _meta: meta,
+    _def: { tag: "regex", source, flags: resolvedFlags },
+    parse(input, pos, ctx) {
+      anchored.lastIndex = pos;
+      const m = anchored.exec(input);
+      if (m === null) {
+        return failAt(ctx, [`/${source}/`], pos);
+      }
+      const span = { start: pos, end: pos + m[0].length };
+      const leaf = { _tag: "leaf", value: m[0], span };
+      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
+      return { ok: true, value: m[0], span };
+    }
+  };
+}
+
+// src/combinators/regex-analyze.ts
 var import_regexp_tree = __toESM(require("regexp-tree"), 1);
 function firstSetFromRegex(pattern) {
   try {
@@ -427,40 +457,6 @@ function extractFirstSet(node2) {
       return { firstSet: any(), canMatchNewline: true };
   }
 }
-function optimizeRegex(source, flags) {
-  try {
-    const result = import_regexp_tree.default.optimize(`/${source}/${flags}`);
-    const str = result.toString();
-    const lastSlash = str.lastIndexOf("/");
-    return str.slice(1, lastSlash);
-  } catch {
-    return source;
-  }
-}
-function regex(pattern, flags = "") {
-  const source = typeof pattern === "string" ? pattern : pattern.source;
-  const resolvedFlags = typeof pattern === "string" ? flags : pattern.flags;
-  const optimizedSource = optimizeRegex(source, resolvedFlags);
-  const anchored = new RegExp(optimizedSource, "y" + resolvedFlags.replace(/[gy]/g, ""));
-  const { firstSet, canMatchNewline } = firstSetFromRegex(source);
-  const meta = { firstSet, canMatchNewline, isTrivia: false };
-  return {
-    _tag: "regex",
-    _meta: meta,
-    _def: { tag: "regex", source, flags: resolvedFlags, optimizedSource },
-    parse(input, pos, ctx) {
-      anchored.lastIndex = pos;
-      const m = anchored.exec(input);
-      if (m === null) {
-        return failAt(ctx, [`/${source}/`], pos);
-      }
-      const span = { start: pos, end: pos + m[0].length };
-      const leaf = { _tag: "leaf", value: m[0], span };
-      if (cstCaptureActive(ctx)) pushCstLeaf(ctx, leaf);
-      return { ok: true, value: m[0], span };
-    }
-  };
-}
 
 // src/combinators/keywords.ts
 function word(str, boundary = "_0-9A-Za-z") {
@@ -1160,12 +1156,14 @@ function confirmedBuildArity(src) {
   return parts.length;
 }
 function buildReadsTrivia(def) {
+  if (!def.build) return true;
   const src = def.buildSrc ?? def.build.toString();
   const arity = confirmedBuildArity(src);
   if (arity === null) return true;
   return arity >= 4;
 }
 function buildReadsState(def) {
+  if (!def.build) return true;
   const src = def.buildSrc ?? def.build.toString();
   const arity = confirmedBuildArity(src);
   if (arity === null) return true;
@@ -1184,8 +1182,8 @@ function node(type, combinator, build, opts) {
   };
   const collapse = opts?.collapse === true;
   const def = collapse ? { tag: "node", type, parser: combinator, build, collapse: true } : { tag: "node", type, parser: combinator, build };
-  const capturesTrivia = buildReadsTrivia(def);
-  const clonesState = buildReadsState(def);
+  const capturesTrivia = build ? buildReadsTrivia(def) : true;
+  const clonesState = build ? buildReadsState(def) : true;
   return {
     _tag: "node",
     _meta: meta,
@@ -1196,13 +1194,8 @@ function node(type, combinator, build, opts) {
       const r = combinator.parse(input, pos, ctx);
       const { children, rawChildren, triviaLog } = endCstNodeCapture(ctx, saved);
       if (!r.ok) return r;
-      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build(
-        children,
-        rawChildren,
-        r.span,
-        triviaLog,
-        clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0
-      );
+      const st = clonesState && ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
+      const built = collapse && children.length === 1 ? collapseChild(children[0]) : build ? build(children, rawChildren, r.span, triviaLog, st) : ctx.build ? ctx.build(type, children, rawChildren, r.span, triviaLog, st) : { _tag: "node", type, span: { start: r.span.start, end: r.span.end }, state: st ?? null, children };
       const isNodeLike = typeof built === "object" && built !== null && built._tag === "node";
       const rawEntry = isNodeLike ? built : { _tag: "leaf", value: typeof built === "string" ? built : "", span: r.span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
@@ -1345,8 +1338,14 @@ function staticExpected(c) {
     case "transform":
     case "not":
       return staticExpected(def.parser);
-    case "lazy":
-      return staticExpected(def.thunk());
+    case "lazy": {
+      const name = c._ruleName;
+      try {
+        return staticExpected(def.thunk());
+      } catch {
+        return name ? [name] : [];
+      }
+    }
     default:
       return [];
   }
@@ -1646,6 +1645,15 @@ function seqIsUnambiguous(parts) {
     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 skippableSingle = p.part === "lit" && p.optional || p.part !== "lit" && !p.unbounded && p.min === 0;
     const isUnboundedRepeat = p.part !== "lit" && p.unbounded;
     if (skippableSingle || isUnboundedRepeat) {
@@ -1692,6 +1700,58 @@ function firstSetsDisjoint(a, b) {
   if (a === "any" || b === "any") return false;
   return classDisjoint(a, b);
 }
+function fixedClassSeq(shape) {
+  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.unbounded && p.min === 1) {
+      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);
+  }
+  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 };
@@ -1703,18 +1763,10 @@ function trailingBacktrackClass(shape) {
       if (last.unbounded || last.min === 0) return { ranges: last.ranges, negated: last.negated };
       return null;
     }
-    const innerWiggle = trailingBacktrackClass(last.inner);
-    if (innerWiggle === "unsupported") return "unsupported";
-    const requiredOnce = !last.unbounded && last.min === 1;
-    if (requiredOnce) return innerWiggle;
-    const dropExposed = shapeFirstAccept(last.inner);
-    if (dropExposed === "any") return "unsupported";
-    if (innerWiggle === null) return dropExposed;
-    const unioned = unionCharSets([innerWiggle, dropExposed]);
-    return unioned === "any" ? "unsupported" : unioned;
+    return groupPartExposure(last);
   }
   if (shape.kind === "alt") {
-    if (!shape.disjoint) return "unsupported";
+    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);
@@ -1854,7 +1906,7 @@ function seqFirstAccept(parts) {
 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 shape.disjoint;
+  if (shape.kind === "alt") return true;
   return false;
 }
 function shapeFirstAccept(shape) {
@@ -1882,9 +1934,8 @@ function shapeFirstAccept(shape) {
       return shapeFirstAccept(shape.inner);
     // zero-width — doesn't change first-char acceptance
     case "alt": {
-      if (!shape.disjoint) return "any";
-      const sets = shape.firsts.filter((f) => f !== null);
-      return sets.length === shape.arms.length ? unionCharSets(sets) : "any";
+      const sets = shape.firsts.map((f) => f === null ? "any" : f);
+      return unionCharSets(sets);
     }
   }
 }
@@ -1925,6 +1976,120 @@ function parseScanShape(source) {
   }
   return parseScanShapeCore(source);
 }
+function splitDelimArms(body) {
+  const arms = [];
+  let depth = 0;
+  let last = 0;
+  let i = 0;
+  while (i < body.length) {
+    const ch = body[i];
+    if (ch === "\\") {
+      i += 2;
+      continue;
+    }
+    if (ch === "[") {
+      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 (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (ch === ")") {
+      depth--;
+      if (depth < 0) return null;
+      i++;
+      continue;
+    }
+    if (ch === "|" && depth === 0) {
+      arms.push(body.slice(last, i));
+      last = i + 1;
+    }
+    i++;
+  }
+  if (depth !== 0) return null;
+  arms.push(body.slice(last));
+  return arms;
+}
+function delimitedBodySound(body, close) {
+  const l0 = close[0];
+  if (close.length > 2) return false;
+  const arms = splitDelimArms(body);
+  if (!arms) return false;
+  let bulkSeen = false;
+  let guardSeen = false;
+  for (const arm of arms) {
+    const bulk = /^\[\^((?:\\.|[^\]])+)\]$/.exec(arm);
+    if (bulk) {
+      if (bulkSeen) return false;
+      const ranges = parseClassRanges(bulk[1]);
+      if (!ranges || ranges.length !== 1 || ranges[0][0] !== l0 || ranges[0][1] !== l0) return false;
+      bulkSeen = true;
+      continue;
+    }
+    if (close.length === 2 && arm.endsWith(")")) {
+      const idx = arm.indexOf("(?!");
+      if (idx === -1) return false;
+      const prefix = literalCodePoints(arm.slice(0, idx));
+      const op = parseClassOperand(arm.slice(idx + 3, -1));
+      const prefixIsL0 = prefix?.length === 1 && prefix[0] === l0;
+      const forbidsL1 = op && !op.negated && op.ranges.length === 1 && op.ranges[0][0] === close[1] && op.ranges[0][1] === close[1];
+      if (!prefixIsL0 || !forbidsL1 || guardSeen) return false;
+      guardSeen = true;
+      continue;
+    }
+    return false;
+  }
+  return bulkSeen && guardSeen === (close.length === 2);
+}
+function parseDelimited(source) {
+  if (source.includes("\\\\")) return null;
+  let i = 0;
+  while (i < source.length && source[i] !== "(") {
+    i += source[i] === "\\" ? 2 : 1;
+  }
+  if (source[i] !== "(" || source[i + 1] !== "?" || source[i + 2] !== ":") return null;
+  const openFrag = source.slice(0, i);
+  let k = i + 3;
+  let depth = 1;
+  while (k < source.length && depth > 0) {
+    const ch = source[k];
+    if (ch === "\\") {
+      k += 2;
+      continue;
+    }
+    if (ch === "[") {
+      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 (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    k++;
+  }
+  if (depth !== 0) return null;
+  const body = source.slice(i + 3, k - 1);
+  if (source[k] !== "*") return null;
+  const closeFrag = source.slice(k + 1);
+  const open = literalCodePoints(openFrag);
+  const close = literalCodePoints(closeFrag);
+  if (!open || !close || !delimitedBodySound(body, close)) return null;
+  return { kind: "delimited", open, close };
+}
 function parseScanShapeCore(source) {
   let m = /^\[((?:\\.|[^\]])+)\]([+*])$/.exec(source);
   if (m && !m[1].startsWith("^")) {
@@ -1949,14 +2114,8 @@ function parseScanShapeCore(source) {
     const stop = parseClassRanges(m[2]);
     if (open && stop) return { kind: "until", open, stop };
   }
-  if (!source.includes("\\\\")) {
-    m = /^(.*?)\((?:\?:)?[\s\S]*\)\*(.*?)$/.exec(source);
-    if (m && m[1] && m[2]) {
-      const open = literalCodePoints(m[1]);
-      const close = literalCodePoints(m[2]);
-      if (open && close) return { kind: "delimited", open, close };
-    }
-  }
+  const delim = parseDelimited(source);
+  if (delim) return delim;
   const parts = parseSeqParts(source);
   if (parts && seqIsUnambiguous(parts)) return { kind: "seq", parts };
   return null;
@@ -2411,6 +2570,7 @@ function looseMkBuildRe(type) {
   );
 }
 function analyzeMkInlineBuild(def) {
+  if (!def.build) return null;
   const src = (def.buildSrc ?? def.build.toString()).trim();
   const strict = src.match(MK_BUILD_RE);
   if (strict) {
@@ -2508,6 +2668,15 @@ function v(ctx, prefix = "_v") {
 function ind(ctx) {
   return "  ".repeat(ctx.indent);
 }
+function nsp(ctx) {
+  return ctx.ns ?? "";
+}
+function mfRef(ctx) {
+  return `${nsp(ctx)}_mf`;
+}
+function buildRef(ctx) {
+  return `${nsp(ctx)}_build`;
+}
 function reindentStmts(stmts, targetLevels) {
   const nonEmpty = stmts.filter((s) => s.trim().length > 0);
   if (nonEmpty.length === 0) return stmts;
@@ -2524,7 +2693,7 @@ function failReturnArr(expectedArr, posExpr) {
 function hoistExpected(ctx, constArrSource) {
   let name = ctx.expectedMap.get(constArrSource);
   if (name === void 0) {
-    name = `_fx${ctx.expectedDecls.length}`;
+    name = `${nsp(ctx)}_fx${ctx.expectedDecls.length}`;
     ctx.expectedDecls.push(`const ${name} = ${constArrSource}`);
     ctx.expectedMap.set(constArrSource, name);
   }
@@ -2623,13 +2792,13 @@ function emitLeafCapture(ctx, valExpr, startExpr, endExpr) {
     `${i}}`
   ];
 }
-function ensureRegexDecl(ctx, optimizedSource, flags) {
+function ensureRegexDecl(ctx, source, flags) {
   const f = "y" + flags.replace(/[gy]/g, "");
-  const key = `${optimizedSource}/${f}`;
+  const key = `${source}/${f}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
-    ctx.regexDecls.push(`const ${rName} = /${optimizedSource}/${f}`);
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${source}/${f}`);
     ctx.regexMap.set(key, rName);
   }
   return rName;
@@ -2638,7 +2807,7 @@ function ensureTriviaFn(ctx) {
   const trivia2 = ctx.activeTrivia;
   const existing = ctx.triviaFnNames.get(trivia2);
   if (existing) return existing;
-  const fnName = `_tf${ctx.triviaFnNames.size}`;
+  const fnName = `${nsp(ctx)}_tf${ctx.triviaFnNames.size}`;
   ctx.triviaFnNames.set(trivia2, fnName);
   ctx.triviaCaptureNames.set(trivia2, fnName);
   const labeledSpec = analyzeLabeledTrivia(trivia2);
@@ -2660,7 +2829,7 @@ function ensureTriviaFn(ctx) {
       for (const arm of regexSpec.arms) {
         const def = arm.parser._def;
         if (def.tag !== "regex") break;
-        reNames.push(ensureRegexDecl(ctx, def.optimizedSource, def.flags));
+        reNames.push(ensureRegexDecl(ctx, def.source, def.flags));
       }
       if (reNames.length === regexSpec.arms.length) {
         ctx.namedFnDecls.push(buildLabeledRegexTriviaFnDecl(fnName, regexSpec, reNames));
@@ -2985,7 +3154,7 @@ function emitKeywords(def, ctx, pos) {
   const key = `${source}/${flags}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
     ctx.regexDecls.push(`const ${rName} = /${source}/${flags}`);
     ctx.regexMap.set(key, rName);
   }
@@ -3019,11 +3188,11 @@ function emitRegex(def, ctx, pos) {
     }
   }
   const flags = "y" + def.flags.replace(/[gy]/g, "");
-  const key = `${def.optimizedSource}/${flags}`;
+  const key = `${def.source}/${flags}`;
   let rName = ctx.regexMap.get(key);
   if (rName === void 0) {
-    rName = `_re${ctx.regexDecls.length}`;
-    ctx.regexDecls.push(`const ${rName} = /${def.optimizedSource}/${flags}`);
+    rName = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
+    ctx.regexDecls.push(`const ${rName} = /${def.source}/${flags}`);
     ctx.regexMap.set(key, rName);
   }
   const mv = v(ctx, "_m");
@@ -3200,7 +3369,7 @@ function emitGreedyClassify(def, superIndex, ctx, pos) {
   const reKey = `${regexDef.source}/${cleanFlags}`;
   let reVar = ctx.regexMap.get(reKey);
   if (reVar === void 0) {
-    reVar = `_re${ctx.regexDecls.length}`;
+    reVar = `${nsp(ctx)}_re${ctx.regexDecls.length}`;
     ctx.regexDecls.push(`const ${reVar} = /${regexDef.source}/${cleanFlags}`);
     ctx.regexMap.set(reKey, reVar);
   }
@@ -3293,7 +3462,7 @@ function emitFirstMatch(def, ctx, pos) {
     if (gate) {
       const gateIdx = ctx.mapFns.length;
       ctx.mapFns.push(gate);
-      gateCond = `_mf[${gateIdx}](_ctx.state)`;
+      gateCond = `${mfRef(ctx)}[${gateIdx}](_ctx.state)`;
     }
     const skipCond = gateCond ? `!${resOkV} && ${gateCond}` : `!${resOkV}`;
     const armHasAutoNot = !!(autoNot && autoNot.length > 0);
@@ -3360,7 +3529,7 @@ function emitTransformChain(p, baseValue, endV, startPos, ctx) {
     ctx.mapFnSrcs.push(def.fnSrc ?? null);
     const vv = v(ctx);
     return {
-      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = _mf[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
+      stmts: [...innerR.stmts, `${ind(ctx)}const ${vv} = ${mfRef(ctx)}[${fnIdx}](${innerR.valueVar}, { start: ${startPos}, end: ${endV} })`],
       valueVar: vv,
       endVar: endV
     };
@@ -3588,16 +3757,17 @@ function emitNot(def, ctx, pos) {
   };
 }
 function emitNode(def, ctx, pos) {
-  const mkType = analyzeMkInlineBuild(def);
+  const structural = def.build === void 0;
+  const mkType = structural ? null : analyzeMkInlineBuild(def);
   let buildIdx = null;
-  if (!mkType) {
+  if (!mkType && !structural) {
     buildIdx = ctx.buildFns.length;
     ctx.buildFns.push(def.build);
     ctx.buildSrcs.push(def.buildSrc ?? null);
   }
   const i = ind(ctx);
-  const capturesTrivia = mkType !== null || buildReadsTrivia(def);
-  const clonesState = 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";
@@ -3620,7 +3790,8 @@ function emitNode(def, ctx, pos) {
     stmts.push(`${i}const ${stV} = _ctx.state !== undefined ? Object.assign({}, _ctx.state) : undefined`);
   }
   const ndV = v(ctx, "_nd");
-  const ndExpr = mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `_build[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
+  const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: { start: ${pos}, end: ${endVar} }, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, pos, endVar, tlV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV})`;
+  const ndExpr = ctx.ns || structural ? `_ctx.build !== undefined ? _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${rawV}, { start: ${pos}, end: ${endVar} }, ${tlV}, ${stV}) : (${buildExpr})` : buildExpr;
   const finalExpr = def.collapse ? `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})` : ndExpr;
   stmts.push(
     `${i}const ${ndV} = ${finalExpr}`,
@@ -3645,8 +3816,9 @@ function emitRuntimeFallback(parser2, ctx, pos) {
   return { stmts, valueVar: vv, endVar: ev };
 }
 function emitLazy(p, def, ctx, pos) {
+  const canonical = ctx.ruleNames?.get(p);
   const usage = ctx.lazyUsage;
-  if (usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
+  if (!canonical && usage && (usage.counts.get(p) ?? 0) <= 1 && !usage.recursive.has(p)) {
     let resolved;
     try {
       resolved = def.thunk();
@@ -3656,7 +3828,7 @@ function emitLazy(p, def, ctx, pos) {
     return emit(resolved, ctx, pos);
   }
   if (!ctx.namedParsers.has(p)) {
-    const fnName2 = `_pf${ctx.namedParsers.size}`;
+    const fnName2 = canonical ?? `${nsp(ctx)}_pf${ctx.namedParsers.size}`;
     ctx.namedParsers.set(p, fnName2);
     let resolved;
     try {
@@ -3774,7 +3946,7 @@ function emit(p, ctx, pos) {
       return {
         stmts: [
           ...inner.stmts,
-          `${ind(ctx)}const ${mv} = _mf[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`
+          `${ind(ctx)}const ${mv} = ${mfRef(ctx)}[${fnIdx}](${inner.valueVar}, { start: ${pos}, end: ${inner.endVar} })`
         ],
         valueVar: mv,
         endVar: inner.endVar
@@ -3837,7 +4009,7 @@ function emit(p, ctx, pos) {
       const vv = v(ctx);
       return {
         stmts: [
-          ...emitIfFail(ctx, `!_mf[${fnIdx}](_ctx.state)`, failBody(ctx, '"gate"', pos)),
+          ...emitIfFail(ctx, `!${mfRef(ctx)}[${fnIdx}](_ctx.state)`, failBody(ctx, '"gate"', pos)),
           `${ind(ctx)}const ${vv} = null`
         ],
         valueVar: vv,
@@ -3870,7 +4042,7 @@ function emit(p, ctx, pos) {
       const ev = v(ctx, "_wce");
       return {
         stmts: [
-          `${ind(ctx)}const ${rv} = { ..._ctx, state: _mf[${evIdx}]() }`,
+          `${ind(ctx)}const ${rv} = { ..._ctx, state: ${mfRef(ctx)}[${evIdx}]() }`,
           `${ind(ctx)}const ${vv} = ${fn}(input, ${pos}, ${rv})`,
           // withCtx runs on a spread child ctx — copy its recorded failure back
           // and propagate the inner failure verbatim (interpreter parity).
@@ -4001,6 +4173,39 @@ function analyzeLazyUsageMulti(roots) {
   for (const root of roots) walk2(root);
   return { counts, recursive };
 }
+function ruleDependencies(ruleMap) {
+  const nameOf = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) nameOf.set(comb, name);
+  const deps = /* @__PURE__ */ new Map();
+  for (const [name, comb] of ruleMap) {
+    const found = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set();
+    const walk2 = (p, isRoot) => {
+      const def = p._def;
+      const boundary = def.tag === "lazy" ? p._ruleName ?? nameOf.get(p) : nameOf.get(p);
+      if (!isRoot && boundary !== void 0) {
+        found.add(boundary);
+        return;
+      }
+      if (seen.has(p)) return;
+      seen.add(p);
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          return;
+        }
+        walk2(resolved, false);
+        return;
+      }
+      for (const child of childrenOf(def)) walk2(child, false);
+    };
+    walk2(comb, true);
+    deps.set(name, [...found]);
+  }
+  return deps;
+}
 function compile(combinator, mapFnSources) {
   const ctx = {
     vars: 0,
@@ -4106,6 +4311,15 @@ function compileRuleMap(ruleMap) {
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule))
   };
+  const seenNames = /* @__PURE__ */ new Map();
+  const ruleNames = /* @__PURE__ */ new Map();
+  for (const [key, rule] of ruleMap) {
+    const base = `_r_${key.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+    const n = seenNames.get(base) ?? 0;
+    seenNames.set(base, n + 1);
+    ruleNames.set(rule, n === 0 ? base : `${base}$${n}`);
+  }
+  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' })
 ` : "";
@@ -4115,8 +4329,8 @@ function compileRuleMap(ruleMap) {
   const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== void 0;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
   if (!canInline) return null;
-  const mfDecl = derivedSrcs?.length ? `  const _mf = [${derivedSrcs.join(", ")}]` : "";
-  const buildDecl = buildSources?.length ? `  const _build = [${buildSources.join(", ")}]` : "";
+  const mfDecl = derivedSrcs?.length ? `  const ${mfRef(ctx)} = [${derivedSrcs.join(", ")}]` : "";
+  const buildDecl = buildSources?.length ? `  const ${buildRef(ctx)} = [${buildSources.join(", ")}]` : "";
   const namedPrelude = ctx.namedFnDecls.length > 0 ? namedFnPrelude() : [];
   const hoistedDecls = [
     ctx.needsEmptyTl ? `  const _EMPTY_TL = Object.freeze([])` : "",
@@ -4149,6 +4363,150 @@ function compileRuleMap(ruleMap) {
   ].join("\n");
   return { keys: perEntry.map((e) => e.key), replacement };
 }
+function compileLinkable(ruleMapArg, ns) {
+  if (!ns) throw new Error("compileLinkable: ns must be a non-empty namespace");
+  const ruleMap = ruleMapArg.filter(([, val]) => {
+    const d = val._def;
+    if (d.tag !== "lazy") return true;
+    try {
+      d.thunk();
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const ctx = {
+    vars: 0,
+    indent: 1,
+    regexDecls: [],
+    regexMap: /* @__PURE__ */ new Map(),
+    expectedDecls: [],
+    expectedMap: /* @__PURE__ */ new Map(),
+    recordFail: true,
+    mapFns: [],
+    mapFnSrcs: [],
+    buildFns: [],
+    buildSrcs: [],
+    runtimeParsers: [],
+    needsCollator: false,
+    namedParsers: /* @__PURE__ */ new Map(),
+    triviaCaptureNames: /* @__PURE__ */ new Map(),
+    triviaFnNames: /* @__PURE__ */ new Map(),
+    namedFnDecls: [],
+    capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
+    lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
+    ns
+  };
+  const seen = /* @__PURE__ */ new Map();
+  const ruleNames = /* @__PURE__ */ new Map();
+  const fnNameToKey = /* @__PURE__ */ new Map();
+  for (const [key, rule] of ruleMap) {
+    const base = `_r_${key.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+    const n = seen.get(base) ?? 0;
+    seen.set(base, n + 1);
+    const fn = n === 0 ? base : `${base}$${n}`;
+    ruleNames.set(rule, fn);
+    fnNameToKey.set(fn, key);
+  }
+  ctx.ruleNames = ruleNames;
+  {
+    const scanned = /* @__PURE__ */ new Set();
+    const scanExternal = (p) => {
+      if (scanned.has(p)) return;
+      scanned.add(p);
+      const def = p._def;
+      if (def.tag === "lazy") {
+        let resolved;
+        try {
+          resolved = def.thunk();
+        } catch {
+          resolved = void 0;
+        }
+        if (resolved === void 0) {
+          const name = p._ruleName;
+          if (name && !ctx.namedParsers.has(p)) {
+            const fn = `_r_${name.replace(/[^A-Za-z0-9_$]/g, "_")}`;
+            ruleNames.set(p, fn);
+            ctx.namedParsers.set(p, fn);
+          }
+          return;
+        }
+        scanExternal(resolved);
+        return;
+      }
+      for (const child of childrenOf(def)) scanExternal(child);
+    };
+    for (const [, rule] of ruleMap) scanExternal(rule);
+  }
+  const perEntry = [];
+  for (const [key, rule] of ruleMap) {
+    const fn = ruleNames.get(rule);
+    if (!ctx.namedParsers.has(rule)) {
+      ctx.namedParsers.set(rule, fn);
+      let resolved = rule;
+      const def = rule._def;
+      if (def.tag === "lazy") {
+        try {
+          resolved = def.thunk();
+        } catch {
+          return null;
+        }
+      }
+      const savedIndent = ctx.indent, savedFail = ctx.failLabel, savedRec = ctx.recordFail;
+      ctx.indent = 1;
+      ctx.failLabel = "_pfail";
+      ctx.recordFail = true;
+      const body = emit(resolved, ctx, "_pos");
+      ctx.indent = savedIndent;
+      ctx.failLabel = savedFail;
+      ctx.recordFail = savedRec;
+      pushNamedFnDecl(ctx, fn, body.stmts, body.valueVar, body.endVar);
+    }
+    perEntry.push({ key, r: emitNamedFnCall(ctx, fn, "_pos") });
+  }
+  if (ctx.runtimeParsers.length !== 0) return null;
+  const mfSrcs = ctx.mapFns.length > 0 && ctx.mapFnSrcs.every((s) => s !== null) ? ctx.mapFnSrcs : null;
+  const buildSrcs = ctx.buildFns.length > 0 && ctx.buildSrcs.every((s) => s !== null) ? ctx.buildSrcs : null;
+  const ruleFns = /* @__PURE__ */ new Map();
+  const privateFns = [];
+  for (const decl of ctx.namedFnDecls) {
+    const fnName = decl.match(/^function (\S+?)\(/)?.[1];
+    const key = fnName ? fnNameToKey.get(fnName) : void 0;
+    if (key !== void 0) ruleFns.set(key, decl);
+    else privateFns.push(decl);
+  }
+  const mfDecl = ctx.mapFns.length === 0 ? "" : mfSrcs ? `const ${mfRef(ctx)} = [${mfSrcs.join(", ")}]` : `const ${mfRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "mf")}]`;
+  const buildDecl = ctx.buildFns.length === 0 ? "" : buildSrcs ? `const ${buildRef(ctx)} = [${buildSrcs.join(", ")}]` : `const ${buildRef(ctx)} = _env[${JSON.stringify(nsp(ctx) + "build")}]`;
+  const prelude = [
+    ...ctx.regexDecls,
+    ...ctx.expectedDecls,
+    mfDecl,
+    buildDecl,
+    ...privateFns
+  ].filter(Boolean);
+  const wrappers = /* @__PURE__ */ new Map();
+  for (const { key, r } of perEntry) {
+    wrappers.set(key, [
+      `function(input, _pos, _ctx) {`,
+      `  let pos = _pos`,
+      ...r.stmts,
+      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `}`
+    ].join("\n"));
+  }
+  return {
+    ns,
+    keys: perEntry.map((e) => e.key),
+    prelude,
+    ruleFns,
+    wrappers,
+    deps: ruleDependencies(ruleMap),
+    needsEmptyTl: !!ctx.needsEmptyTl,
+    needsCollator: ctx.needsCollator,
+    mfFns: mfSrcs ? [] : ctx.mapFns,
+    buildFns: buildSrcs ? [] : ctx.buildFns
+  };
+}
 function buildInlineExpression(ctx, r, collatorDecl, mapFnSources, buildSources) {
   const bodyLines = [
     `  let pos = _pos`,
@@ -4187,6 +4545,48 @@ 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 body = [...lines, "return {", wrapperEntries.join(",\n"), "}"].join("\n");
+  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 = {
@@ -4281,6 +4681,12 @@ function escapeClassChar(ch) {
   return ch.replace(/[\\\]^-]/g, "\\$&");
 }
 
+// src/cst/offset-model.ts
+var { isFinite } = Number;
+
+// src/index.ts
+registerRegexAnalyzer(firstSetFromRegex);
+
 // src/plugin/evaluator.ts
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
@@ -4380,16 +4786,18 @@ function exprToCombi(node2, scope, code, mfs) {
   }
   if (callee.name === "node" && code !== void 0) {
     const [typeArg, parserArg, buildArg, optsArg] = node2.arguments;
-    if (!typeArg || !parserArg || !buildArg || typeArg.type === "SpreadElement" || parserArg.type === "SpreadElement" || buildArg.type === "SpreadElement") return null;
+    if (!typeArg || !parserArg || typeArg.type === "SpreadElement" || parserArg.type === "SpreadElement") return null;
     const typeVal = anyValue(typeArg, scope, code);
     if (typeof typeVal !== "string") return null;
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
-    const buildSrc = code.slice(buildArg.start, buildArg.end);
+    const be = buildArg;
+    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && !(be.type === "Identifier" && be.name === "undefined");
+    const buildSrc = hasBuild ? code.slice(be.start, be.end) : void 0;
     const collapse = optsArg !== void 0 && optsArg.type !== "SpreadElement" ? staticCollapseOption(optsArg) : false;
     try {
-      const combi = node(typeVal, inner, () => null, collapse ? { collapse: true } : void 0);
-      if (combi._def.tag === "node") combi._def.buildSrc = buildSrc;
+      const combi = node(typeVal, inner, hasBuild ? () => null : void 0, collapse ? { collapse: true } : void 0);
+      if (combi._def.tag === "node" && buildSrc !== void 0) combi._def.buildSrc = buildSrc;
       return combi;
     } catch {
       return null;
@@ -4575,91 +4983,24 @@ function evaluateCombinatorArray(node2, scope, code) {
   if (!val.every(isCombinator)) return null;
   return val;
 }
-function asFragmentFactory(expr) {
-  if (expr.type !== "ArrowFunctionExpression" && expr.type !== "FunctionExpression" && expr.type !== "FunctionDeclaration") return null;
-  const fn = expr;
-  return factoryBodyAndReturn(fn) ? fn : null;
-}
-var unwrapParen = (e) => e && e.type === "ParenthesizedExpression" ? e.expression : e;
-function factoryBodyAndReturn(fn) {
-  const body = fn.body;
-  if (!body) return null;
-  const b = unwrapParen(body);
-  if (b.type === "ObjectExpression") return { statements: [], retObj: b };
-  if (b.type === "BlockStatement") {
-    const statements = [];
-    for (const stmt of b.body) {
-      if (stmt.type === "ReturnStatement") {
-        const a = unwrapParen(stmt.argument);
-        if (!a || a.type !== "ObjectExpression") return null;
-        return { statements, retObj: a };
-      }
-      if (stmt.type === "VariableDeclaration") statements.push(stmt);
-      else return null;
-    }
-  }
-  return null;
-}
-function spreadFactoryCall(spread, resolve) {
-  const call = spread.argument;
-  if (!call || call.type !== "CallExpression") return null;
-  if (!call.callee || call.callee.type !== "Identifier" || !call.callee.name) return null;
-  const resolved = resolve(call.callee.name);
-  return resolved ? { fn: resolved.fn, args: call.arguments ?? [], code: resolved.code } : null;
-}
-function factoryCallScope(fn, args, outer) {
-  const s = new Map(outer);
-  const params = fn.params ?? [];
-  for (let i = 0; i < params.length; i++) {
-    const pn = params[i];
-    if (!pn || pn.type !== "Identifier" || !pn.name) continue;
-    const arg = args[i];
-    if (arg && arg.type === "Identifier" && arg.name && outer.has(arg.name)) {
-      s.set(pn.name, outer.get(arg.name));
-    }
-  }
-  return s;
-}
 function propKey(prop) {
   if (prop.type !== "Property" || prop.computed || !prop.key) return null;
   if (prop.key.type === "Identifier") return prop.key.name ?? null;
   if (prop.key.type === "Literal") return String(prop.key.value);
   return null;
 }
-function collectRuleKeys(retObj, resolve, seen) {
+function collectRuleKeys(retObj) {
   const out = [];
   for (const prop of retObj.properties) {
-    if (prop.type === "SpreadElement") {
-      const sf = spreadFactoryCall(prop, resolve);
-      if (!sf || seen.has(sf.fn)) return null;
-      const br = factoryBodyAndReturn(sf.fn);
-      if (!br) return null;
-      const nested = collectRuleKeys(br.retObj, resolve, new Set(seen).add(sf.fn));
-      if (!nested) return null;
-      out.push(...nested);
-      continue;
-    }
     const key = propKey(prop);
     if (!key) return null;
     out.push(key);
   }
   return out;
 }
-function flattenRuleEntries(retObj, scope, code, resolve, seen) {
+function flattenRuleEntries(retObj, scope, code) {
   const out = [];
   for (const prop of retObj.properties) {
-    if (prop.type === "SpreadElement") {
-      const sf = spreadFactoryCall(prop, resolve);
-      if (!sf || seen.has(sf.fn)) return null;
-      const br = factoryBodyAndReturn(sf.fn);
-      if (!br) return null;
-      const fragScope = factoryCallScope(sf.fn, sf.args, scope);
-      if (!evalBodyStatements(br.statements, fragScope, sf.code)) return null;
-      const nested = flattenRuleEntries(br.retObj, fragScope, sf.code, resolve, new Set(seen).add(sf.fn));
-      if (!nested) return null;
-      out.push(...nested);
-      continue;
-    }
     const key = propKey(prop);
     if (!key) return null;
     out.push({ key, value: prop.value, scope, code });
@@ -4685,7 +5026,7 @@ function evalBodyStatements(statements, scope, code) {
   }
   return true;
 }
-function evaluateParserFactory(factoryNode, scope, code, mapFnSources, resolveFactory = () => null) {
+function evaluateParserFactory(factoryNode, scope, code, mapFnSources) {
   if (factoryNode.type !== "ArrowFunctionExpression" && factoryNode.type !== "FunctionDeclaration" && factoryNode.type !== "FunctionExpression") return null;
   const factory = factoryNode;
   const params = factory.params;
@@ -4717,16 +5058,36 @@ function evaluateParserFactory(factoryNode, scope, code, mapFnSources, resolveFa
   if (!returnExpr) return null;
   const retObj = returnExpr.type === "ParenthesizedExpression" ? returnExpr.expression : returnExpr;
   if (retObj.type !== "ObjectExpression") return null;
-  const keys = collectRuleKeys(retObj, resolveFactory, /* @__PURE__ */ new Set());
+  const keys = collectRuleKeys(retObj);
   if (!keys) return null;
   const ruleRefs = /* @__PURE__ */ new Map();
+  const tagRef = (r, name) => {
+    r._ruleName = name;
+  };
   for (const key of keys) {
-    if (!ruleRefs.has(key)) ruleRefs.set(key, ref());
-  }
+    if (!ruleRefs.has(key)) {
+      const r = ref();
+      tagRef(r, key);
+      ruleRefs.set(key, r);
+    }
+  }
+  const externalRefs = /* @__PURE__ */ new Map();
+  const gProxy = new Proxy(Object.fromEntries(ruleRefs), {
+    get(target, prop) {
+      if (typeof prop !== "string" || prop in target) return target[prop];
+      let ext = externalRefs.get(prop);
+      if (!ext) {
+        ext = ref();
+        tagRef(ext, prop);
+        externalRefs.set(prop, ext);
+      }
+      return ext;
+    }
+  });
   const localScope = new Map(scope);
-  localScope.set(proxyName, Object.fromEntries(ruleRefs));
+  localScope.set(proxyName, gProxy);
   if (!evalBodyStatements(statements, localScope, code)) return null;
-  const entries = flattenRuleEntries(retObj, localScope, code, resolveFactory, /* @__PURE__ */ new Set());
+  const entries = flattenRuleEntries(retObj, localScope, code);
   if (!entries) return null;
   const finalByKey = /* @__PURE__ */ new Map();
   for (const e of entries) finalByKey.set(e.key, e);
@@ -4788,19 +5149,14 @@ function referencesAny(node2, names, scope) {
 }
 
 // src/plugin/index.ts
+var import_node_crypto = require("node:crypto");
 var PARSEMAN_MODULE = "parseman";
-var _fragmentResolver = null;
-function getFragmentResolver() {
-  return _fragmentResolver ??= new import_oxc_resolver.ResolverFactory({
-    extensions: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"],
-    // TS/NodeNext style: a `./x.js` import may point at `./x.ts` source.
-    extensionAlias: {
-      ".js": [".ts", ".tsx", ".js", ".jsx"],
-      ".mjs": [".mts", ".mjs"],
-      ".cjs": [".cts", ".cjs"]
-    },
-    conditionNames: ["source", "development", "import", "require", "default"],
-    mainFields: ["source", "module", "main"]
+var _compiledResolver = null;
+function getCompiledResolver() {
+  return _compiledResolver ??= new import_oxc_resolver.ResolverFactory({
+    extensions: [".js", ".mjs", ".cjs"],
+    conditionNames: ["import", "require", "default"],
+    mainFields: ["module", "main"]
   });
 }
 var _moduleParseCache = /* @__PURE__ */ new Map();
@@ -4847,6 +5203,77 @@ var plugin_default = (0, import_unplugin.createUnplugin)((opts = {}) => ({
     return { code: result.code, map: result.map };
   }
 }));
+function exportLocalName(body, exported) {
+  for (const st of body) {
+    if (st.type !== "ExportNamedDeclaration") continue;
+    const decl = st.declaration;
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations ?? []) {
+        const idn = d.id;
+        if (idn?.type === "Identifier" && idn.name === exported) return exported;
+      }
+    }
+    for (const sp of st.specifiers ?? []) {
+      const exp = sp.exported?.name;
+      const loc = sp.local?.name;
+      if (exp === exported && loc) return loc;
+    }
+  }
+  return null;
+}
+function topLevelInit(body, name) {
+  for (const st of body) {
+    const vd = st.type === "VariableDeclaration" ? st : st.type === "ExportNamedDeclaration" && st.declaration?.type === "VariableDeclaration" ? st.declaration : null;
+    if (!vd) continue;
+    for (const d of vd.declarations ?? []) {
+      const idn = d.id;
+      if (idn?.type === "Identifier" && idn.name === name && d.init) return d.init;
+    }
+  }
+  return null;
+}
+function isComposedPiecesSymbol(n) {
+  if (!n || n.type !== "CallExpression") return false;
+  const callee = n.callee;
+  const obj = callee?.object?.name;
+  const prop = callee?.property?.name;
+  const arg0 = n.arguments?.[0];
+  return obj === "Symbol" && prop === "for" && arg0?.value === "parseman.composedPieces";
+}
+function findCarriedPiecesLiteral(root) {
+  let found = null;
+  const visit = (n) => {
+    if (found || !n || typeof n !== "object") return;
+    if (Array.isArray(n)) {
+      for (const c of n) visit(c);
+      return;
+    }
+    const node2 = n;
+    if (node2.type === "CallExpression") {
+      const callee = node2.callee;
+      const obj = callee?.object?.name;
+      const prop = callee?.property?.name;
+      const args = node2.arguments;
+      if (obj === "Object" && prop === "defineProperty" && args && isComposedPiecesSymbol(args[1])) {
+        const descriptor = args[2];
+        for (const p of descriptor?.properties ?? []) {
+          const key = p.key;
+          if ((key?.name === "value" || key?.value === "value") && p.value) {
+            found = { start: p.value.start, end: p.value.end };
+            return;
+          }
+        }
+      }
+    }
+    for (const k in node2) {
+      if (k === "type" || k === "start" || k === "end") continue;
+      const v2 = node2[k];
+      if (v2 && typeof v2 === "object") visit(v2);
+    }
+  };
+  visit(root);
+  return found;
+}
 function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSEMAN_MODULE])) {
   let result;
   try {
@@ -4884,63 +5311,6 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   }
   if (macroImports.length === 0) return null;
   const scope = /* @__PURE__ */ new Map();
-  const factories = /* @__PURE__ */ new Map();
-  const resolver = getFragmentResolver();
-  const importedFactoryCache = /* @__PURE__ */ new Map();
-  const OUTPUT_DIR = /([\\/])(dist|lib|build|out|output|compiled|cjs|esm|es)([\\/])/;
-  const resolveSourcePath = (spec) => {
-    let resolved = null;
-    try {
-      resolved = resolver.resolveFileSync(id, spec).path ?? null;
-    } catch {
-    }
-    if (!resolved) return null;
-    if (OUTPUT_DIR.test(resolved)) {
-      const srcCandidate = resolved.replace(OUTPUT_DIR, "$1src$3").replace(/\.(c|m)?js$/, ".ts");
-      try {
-        if (fs.statSync(srcCandidate).isFile()) return srcCandidate;
-      } catch {
-      }
-    }
-    return resolved;
-  };
-  const resolveImportedFactory = (name) => {
-    if (importedFactoryCache.has(name)) return importedFactoryCache.get(name);
-    let result2 = null;
-    const binding = importBindings.get(name);
-    if (binding) {
-      const filePath = resolveSourcePath(binding.source);
-      const mod = filePath ? parseModuleCached(filePath) : null;
-      if (mod) {
-        for (const st of mod.body) {
-          if (st.type !== "ExportNamedDeclaration" || !st.declaration) continue;
-          const decl = st.declaration;
-          if (decl.type === "VariableDeclaration") {
-            for (const d of decl.declarations ?? []) {
-              if (d.id?.type === "Identifier" && d.id.name === binding.imported && d.init) {
-                const fac = asFragmentFactory(d.init);
-                if (fac) {
-                  result2 = { fn: fac, code: mod.src };
-                  break;
-                }
-              }
-            }
-          } else if (decl.type === "FunctionDeclaration" && decl.id?.type === "Identifier" && decl.id.name === binding.imported) {
-            const fac = asFragmentFactory(decl);
-            if (fac) result2 = { fn: fac, code: mod.src };
-          }
-          if (result2) break;
-        }
-      }
-    }
-    importedFactoryCache.set(name, result2);
-    return result2;
-  };
-  const resolveFactory = (n) => {
-    const local = factories.get(n);
-    if (local) return { fn: local, code };
-    return resolveImportedFactory(n);
-  };
   const replacements = [];
   const warnings = [];
   let anyUnresolved = false;
@@ -4961,7 +5331,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       warn(init.start, `${label2}: rules() needs a factory argument`);
       return null;
     }
-    const ruleMap = evaluateParserFactory(factoryArg, scope, code, [], resolveFactory);
+    const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
     if (!ruleMap) {
       warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
@@ -4974,6 +5344,89 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     return { replacement: compiled.replacement, ruleMap };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
+  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 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)}, deps: ${mapLit(p.deps)}, needsEmptyTl: ${p.needsEmptyTl}, needsCollator: ${p.needsCollator}, 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 localComposedPieces = /* @__PURE__ */ new Map();
+  const importedPiecesCache = /* @__PURE__ */ new Map();
+  const importedPieces = (localName) => {
+    if (importedPiecesCache.has(localName)) return importedPiecesCache.get(localName);
+    let result2 = null;
+    const binding = importBindings.get(localName);
+    if (binding) {
+      let file = null;
+      try {
+        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;
+          }
+        }
+      }
+    }
+    importedPiecesCache.set(localName, result2);
+    return result2;
+  };
+  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;
+    }
+    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;
+      }
+      const composed = localComposedPieces.get(name);
+      if (composed) return composed;
+      return importedPieces(name);
+    }
+    return null;
+  };
+  const compileComposeCall = (init) => {
+    const args = init.arguments;
+    const arr = args[0];
+    if (!arr || arr.type !== "ArrayExpression") {
+      warn(init.start, "compose(): expected a static array of grammars/artifacts");
+      return null;
+    }
+    const elements = arr.elements;
+    const pieces = [];
+    for (let i = 0; i < elements.length; i++) {
+      const list = argPieces(elements[i], `compose${init.start}_${i}`);
+      if (!list) {
+        warn(init.start, `compose(): argument ${i} isn't a build-resolvable grammar; falling back to runtime`);
+        return null;
+      }
+      pieces.push(...list);
+    }
+    try {
+      return { replacement: emitFusedSource(pieces), pieces };
+    } catch (e) {
+      warn(init.start, `compose(): ${e.message}; falling back to runtime`);
+      return null;
+    }
+  };
   const unwrapVd = (stmt) => stmt.type === "VariableDeclaration" ? stmt : stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : null;
   const refNames = /* @__PURE__ */ new Set();
   for (const stmt of body) {
@@ -5052,16 +5505,23 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         if (isRulesCall(init)) {
           const compiledRules = compileRulesFactory(init, varName);
           if (!compiledRules) continue;
-          replacements.push({
-            start: init.start,
-            end: init.end,
-            replacement: compiledRules.replacement
-          });
+          localRuleMaps.set(varName, compiledRules.ruleMap);
+          let replacement = compiledRules.replacement;
+          if (exportPrefix) {
+            const pieces = compileLinkable([...compiledRules.ruleMap], nsFor(varName));
+            if (pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
+              replacement = withCarriedPieces(replacement, [pieces]);
+            }
+          }
+          replacements.push({ start: init.start, end: init.end, replacement });
           continue;
         }
-        const frag = asFragmentFactory(init);
-        if (frag) {
-          factories.set(varName, frag);
+        if (isComposeCall(init)) {
+          const fused = compileComposeCall(init);
+          if (!fused) continue;
+          localComposedPieces.set(varName, fused.pieces);
+          const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.pieces) : fused.replacement;
+          replacements.push({ start: init.start, end: init.end, replacement });
           continue;
         }
         const mapFnSources = [];