parseman 0.45.0 → 0.46.0

package/dist/plugin/index.js

@@ -2,7 +2,7 @@
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 import { createUnplugin } from "unplugin";
-import { parseSync as parseSync3 } from "oxc-parser";
+import { parseSync as parseSync4 } from "oxc-parser";
 import { ResolverFactory } from "oxc-resolver";
 import MagicString from "magic-string";
 
@@ -1492,8 +1492,8 @@ function classifyTriviaArm(arm) {
   }
   const lc = /^(\\?.)\[\^\\n\\r\]\*$/.exec(arm);
   if (lc) {
-    const marker = lc[1];
-    return { kind: "untilLineBreak", code: (marker.length === 2 ? marker[1] : marker[0]).charCodeAt(0) };
+    const marker2 = lc[1];
+    return { kind: "untilLineBreak", code: (marker2.length === 2 ? marker2[1] : marker2[0]).charCodeAt(0) };
   }
   return null;
 }
@@ -3391,7 +3391,8 @@ var RESOLVER_REASONS = {
   "unresolved-import": "its module could not be resolved or parsed",
   "not-found": "the name did not resolve to any binding",
   "computed": "it is a computed expression",
-  "foreign-source": "it is named inside an imported factory, whose offsets the entry-file resolver cannot index"
+  "foreign-source": "it is named in a module the resolver was never told about, so its offsets index no scope tree the resolver holds",
+  "ambiguous-source": "two distinct registered modules hold byte-identical text, so that text no longer names the module its offsets index"
 };
 function unconfirmableReason(def, src) {
   const declared = def.buildArityUnresolved;
@@ -3920,7 +3921,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.45.0";
+var PARSEMAN_VERSION = "0.46.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -5540,15 +5541,15 @@ function parseStringShape(source) {
   if (source.length < 3 || source[source.length - 1] !== q) return null;
   const inner = source.slice(1, -1);
   const CLS = String.raw`\[\^((?:\\.|[^\]])+)\]`;
-  const ESC = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
+  const ESC2 = String.raw`\\\\(\.|\[\\s\\S\]|\[\\S\\s\])`;
   let body;
   let esc;
-  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC}\\)\\*$`).exec(inner);
+  let m = new RegExp(`^\\((?:\\?:)?${CLS}\\|${ESC2}\\)\\*$`).exec(inner);
   if (m) {
     body = m[1];
     esc = m[2];
   } else {
-    m = new RegExp(`^\\((?:\\?:)?${ESC}\\|${CLS}\\)\\*$`).exec(inner);
+    m = new RegExp(`^\\((?:\\?:)?${ESC2}\\|${CLS}\\)\\*$`).exec(inner);
     if (m) {
       esc = m[1];
       body = m[2];
@@ -11224,7 +11225,7 @@ function pickPieces(pieces, names) {
   const filt = (m, pc) => new Map([...m].filter(([k]) => keep.has(k) && winner.get(k) === pc));
   return pieces.map((pc) => ({ ...pc, keys: pc.keys.filter((k) => keep.has(k) && winner.get(k) === pc), ruleFns: filt(pc.ruleFns, pc), wrappers: filt(pc.wrappers, pc), deps: filt(pc.deps, pc), nodeMeta: filt(pc.nodeMeta, pc) })).filter((pc) => pc.keys.length > 0);
 }
-function fusedBody(pieces) {
+function fusedBody(pieces, hoist) {
   for (const p of pieces) {
     if (p.v === void 0) {
       throw new Error(
@@ -11264,8 +11265,7 @@ function fusedBody(pieces) {
   const wrapperEntries = [...winner].map(([k, p]) => `${JSON.stringify(k)}: ${p.wrappers.get(k)}`);
   const reflection = mergeGrammarReflections([...winner].map(([k, p]) => p.nodeMeta.get(k) ?? { nodes: [] }));
   const { mode, elided } = hostModeOfPieces(pieces);
-  const rawBody = [
-    ...lines,
+  const tailSrc = [
     "const _map = {",
     wrapperEntries.join(",\n"),
     "}",
@@ -11281,6 +11281,7 @@ function fusedBody(pieces) {
     "}",
     "return _map"
   ].join("\n");
+  const rawBody = [...lines, tailSrc].join("\n");
   const ANY2 = { kind: "any" };
   const EMPTY3 = { kind: "empty" };
   const recipes = /* @__PURE__ */ new Map();
@@ -11321,7 +11322,7 @@ function fusedBody(pieces) {
     }
     if (!changed) break;
   }
-  const body = rawBody.replace(
+  const resolveFS = (src) => src.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.
@@ -11332,6 +11333,7 @@ function fusedBody(pieces) {
       return `(${firstSetCond(codevar, fs3)})`;
     }
   );
+  const body = hoist === void 0 ? resolveFS(rawBody) : [...hoist.claim(lines.map(resolveFS)), resolveFS(tailSrc)].join("\n");
   const env = {};
   for (const p of contributingPieces) {
     if (p.mfFns.length) env[`${p.ns}mf`] = p.mfFns;
@@ -11349,8 +11351,8 @@ function hostModeOfPieces(pieces) {
   }
   return { mode, elided: elided.length > 0 };
 }
-function emitFusedSource(pieces) {
-  const { body, env } = fusedBody(pieces);
+function emitFusedSource(pieces, hoist) {
+  const { body, env } = fusedBody(pieces, hoist);
   if (Object.keys(env).length > 0) {
     throw new Error("emitFusedSource: artifact carries non-static callbacks (runtime-only); cannot emit static source");
   }
@@ -11373,6 +11375,34 @@ function materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   return pieces;
 }
 
+// src/functional/run.ts
+var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
+var REMOVED_RUN_RESULT_FIELDS = [
+  [
+    "triviaMap",
+    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
+  ],
+  [
+    "triviaLog",
+    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
+  ],
+  [
+    "triviaKindLabels",
+    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
+  ]
+];
+
+// src/analysis/choice-cost-render.ts
+var ESC = "\x1B";
+var ANSI = {
+  dim: `${ESC}[2m`,
+  bold: `${ESC}[1m`,
+  red: `${ESC}[31m`,
+  yellow: `${ESC}[33m`,
+  cyan: `${ESC}[36m`,
+  reset: `${ESC}[0m`
+};
+
 // src/combinators/gate.ts
 function gate(predicate) {
   const meta = {
@@ -11392,23 +11422,6 @@ function gate(predicate) {
   };
 }
 
-// src/functional/run.ts
-var SELECT_EXAMPLE = "run(entry, input, { rootTrivia: { select: ['blockComment', 'lineComment'] } })";
-var REMOVED_RUN_RESULT_FIELDS = [
-  [
-    "triviaMap",
-    `It was a dense root-trivia index built on every parse; root trivia is now an OPT-IN sparse capture, because most grammars paid for an index they never read. Migration: name the trivia labels your grammar defines \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia\`, whose \`.index\` carries the labels and gap lookups \`triviaMap\` exposed.`
-  ],
-  [
-    "triviaLog",
-    `It was the flat \`start, end[, kindIndex]\` log every other trivia view was derived from, and it is no longer allocated at all \u2014 not empty, absent. Migration: request the labels you need \u2014 ${SELECT_EXAMPLE} \u2014 and read \`RunResult.rootTrivia.rows\`. Do NOT reuse a stride-2/3 reader: rows are a different width and a different unit (one row per SELECTED marker, not one per trivia chunk), so an old loop reads confidently wrong offsets rather than failing.`
-  ],
-  [
-    "triviaKindLabels",
-    `It was already optional, so nothing ever flagged its disappearance \u2014 and \`triviaKindMask(undefined, \u2026)\` means "capture everything", so reading it now silently WIDENS capture instead of erroring. Migration: request labels \u2014 ${SELECT_EXAMPLE} \u2014 then the set you asked for is \`RunResult.rootTrivia.select\` and the resolved table is \`RunResult.rootTrivia.index.labels\`.`
-  ]
-];
-
 // src/index.ts
 registerRegexAnalyzer(firstSetFromRegex);
 
@@ -11602,8 +11615,10 @@ function stripTsFromSource(node2, code) {
   return out + code.slice(cur, end);
 }
 var _reducers = null;
-function setReducerResolver(r) {
+var _entrySource = null;
+function setReducerResolver(r, entrySource = null) {
   _reducers = r;
+  _entrySource = entrySource;
 }
 function isWordFactory(v2) {
   return !!v2 && typeof v2 === "object" && v2.tag === "wordFactory";
@@ -11975,6 +11990,9 @@ function exprToCombi(node2, scope, code, mfs) {
         const resolved = _reducers?.resolve(buildSrc, be.start, code);
         if (resolved) {
           if (resolved.src !== null) combi._def.buildSigSrc = resolved.src;
+          if (_entrySource !== null && code !== _entrySource && resolved.src !== null && be.type === "Identifier") {
+            combi._def.buildSrc = resolved.src;
+          }
           if (combi._def.buildArity === void 0 && resolved.arity !== null) combi._def.buildArity = resolved.arity;
           if (resolved.reason !== void 0) combi._def.buildArityUnresolved = resolved.reason;
         }
@@ -12790,6 +12808,8 @@ function createReducerResolver(entryFile, body, src) {
   const scopes = buildScopeTree(body, src.length);
   markReassignments(body, scopes);
   const entry = { file: entryFile, src, body, scopes };
+  const registered = /* @__PURE__ */ new Map();
+  const ambiguous = /* @__PURE__ */ new Set();
   const fromBinding = (mod, binding, memberName, hops, seen) => {
     if (hops > MAX_HOPS) return { arity: null, src: null, reason: "not-found" };
     if (binding.reassigned) return { arity: null, src: null, reason: "reassigned" };
@@ -12834,19 +12854,342 @@ function createReducerResolver(entryFile, body, src) {
     return { arity, src: mod.src.slice(init.start, init.end), ...reason ? { reason } : {} };
   };
   return {
+    register(file) {
+      const mod = analyseModuleFile(file);
+      if (!mod) return false;
+      if (mod.src === src) return true;
+      const prior = registered.get(mod.src);
+      if (prior !== void 0 && prior.file !== mod.file) {
+        ambiguous.add(mod.src);
+        registered.delete(mod.src);
+        return false;
+      }
+      if (!ambiguous.has(mod.src)) registered.set(mod.src, mod);
+      return !ambiguous.has(mod.src);
+    },
     resolve(exprSrc, offset, offsetSrc) {
       const text = exprSrc.trim();
       const ident = IDENT_RE.test(text) ? text : null;
       const member = ident ? null : MEMBER_RE.exec(text);
       if (!ident && !member) return null;
-      if (offsetSrc !== src) return { arity: null, src: null, reason: "foreign-source" };
+      const mod = offsetSrc === src ? entry : registered.get(offsetSrc);
+      if (!mod) {
+        return { arity: null, src: null, reason: ambiguous.has(offsetSrc) ? "ambiguous-source" : "foreign-source" };
+      }
       const name = ident ?? member[1];
       const memberName = ident ? void 0 : member[2];
-      const hit = lookup(scopeAt(scopes, offset), name);
+      const hit = lookup(scopeAt(mod.scopes, offset), name);
       if (!hit) return { arity: null, src: null, reason: "not-found" };
-      return fromBinding(entry, hit.binding, memberName, 0, /* @__PURE__ */ new Set());
+      return fromBinding(mod, hit.binding, memberName, 0, /* @__PURE__ */ new Set());
+    }
+  };
+}
+
+// src/plugin/free-identifiers.ts
+import { parseSync as parseSync3 } from "oxc-parser";
+var isNode = (v2) => typeof v2 === "object" && v2 !== null && typeof v2.type === "string";
+var TYPE_KEYS = /* @__PURE__ */ new Set([
+  "typeAnnotation",
+  "returnType",
+  "typeParameters",
+  "typeArguments",
+  "superTypeArguments",
+  "typeName",
+  "implements",
+  "extends",
+  "accessibility"
+]);
+var TS_VALUE_WRAPPERS = /* @__PURE__ */ new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "TSInstantiationExpression",
+  "TSTypeAssertion"
+]);
+var HOST_GLOBALS = /* @__PURE__ */ new Set([
+  ...Object.getOwnPropertyNames(globalThis),
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "arguments",
+  "window",
+  "document",
+  "self",
+  "navigator",
+  "location",
+  "top",
+  "parent",
+  "require",
+  "module",
+  "exports",
+  "__dirname",
+  "__filename"
+]);
+function bindPattern(pattern, out) {
+  if (!isNode(pattern)) return;
+  switch (pattern.type) {
+    case "Identifier":
+    case "BindingIdentifier":
+      out.add(String(pattern.name));
+      return;
+    case "ObjectPattern":
+      for (const prop of pattern.properties ?? []) {
+        if (!isNode(prop)) continue;
+        if (prop.type === "RestElement" || prop.type === "BindingRestElement") bindPattern(prop.argument, out);
+        else bindPattern(prop.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const el of pattern.elements ?? []) bindPattern(el, out);
+      return;
+    case "AssignmentPattern":
+      bindPattern(pattern.left, out);
+      return;
+    case "RestElement":
+    case "BindingRestElement":
+      bindPattern(pattern.argument, out);
+      return;
+    case "TSParameterProperty":
+      bindPattern(pattern.parameter, out);
+      return;
+    default:
+      return;
+  }
+}
+function collectBindings(node2, out) {
+  if (Array.isArray(node2)) {
+    for (const child of node2) collectBindings(child, out);
+    return;
+  }
+  if (!isNode(node2)) return;
+  switch (node2.type) {
+    case "ImportSpecifier":
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+      if (isNode(node2.local)) out.add(String(node2.local.name));
+      break;
+    case "VariableDeclarator":
+      bindPattern(node2.id, out);
+      break;
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+    case "TSDeclareFunction":
+    case "ArrowFunctionExpression":
+      if (isNode(node2.id)) out.add(String(node2.id.name));
+      for (const p of node2.params?.items ?? node2.params ?? []) bindPattern(p, out);
+      if (isNode(node2.params) && node2.params.rest) bindPattern(node2.params.rest, out);
+      break;
+    case "ClassDeclaration":
+    case "ClassExpression":
+      if (isNode(node2.id)) out.add(String(node2.id.name));
+      break;
+    case "CatchClause":
+      if (node2.param) {
+        bindPattern(isNode(node2.param) && node2.param.pattern ? node2.param.pattern : node2.param, out);
+      }
+      break;
+    default:
+      break;
+  }
+  for (const key of Object.keys(node2)) {
+    if (key === "type" || key === "start" || key === "end") continue;
+    collectBindings(node2[key], out);
+  }
+}
+var FUNCTION_TYPES2 = /* @__PURE__ */ new Set(["ArrowFunctionExpression", "FunctionExpression", "FunctionDeclaration"]);
+function describeTopLevel(stmt) {
+  const declared = /* @__PURE__ */ new Set();
+  let target = stmt;
+  let prefix = "";
+  let exported = false;
+  if (stmt.type === "ExportNamedDeclaration" || stmt.type === "ExportDefaultDeclaration") {
+    exported = true;
+    prefix = "export ";
+    if (!isNode(stmt.declaration)) return { declared, exported, declaresOnlyFunctions: false, label: `${prefix}{ \u2026 }` };
+    target = stmt.declaration;
+  }
+  if (target.type === "VariableDeclaration") {
+    const decls = (target.declarations ?? []).filter(isNode);
+    for (const d of decls) bindPattern(d.id, declared);
+    const declaresOnlyFunctions = decls.length > 0 && decls.every((d) => isNode(d.init) && FUNCTION_TYPES2.has(d.init.type));
+    const name = [...declared][0];
+    return {
+      declared,
+      exported,
+      declaresOnlyFunctions,
+      label: name ? `${prefix}${String(target.kind)} ${name}` : null
+    };
+  }
+  if (target.type === "FunctionDeclaration" && isNode(target.id)) {
+    declared.add(String(target.id.name));
+    return { declared, exported, declaresOnlyFunctions: true, label: `${prefix}function ${String(target.id.name)}` };
+  }
+  if (target.type === "ClassDeclaration" && isNode(target.id)) {
+    declared.add(String(target.id.name));
+    return { declared, exported, declaresOnlyFunctions: false, label: `${prefix}class ${String(target.id.name)}` };
+  }
+  return { declared, exported, declaresOnlyFunctions: false, label: null };
+}
+function findFreeIdentifiers(code, filename) {
+  let parsed;
+  try {
+    parsed = parseSync3(filename, code);
+  } catch {
+    return [];
+  }
+  if (parsed.errors.length > 0) return [];
+  const bound = /* @__PURE__ */ new Set();
+  collectBindings(parsed.program.body, bound);
+  const lineStarts = [0];
+  for (let i = 0; i < code.length; i++) if (code.charCodeAt(i) === 10) lineStarts.push(i + 1);
+  const positionOf = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return { line: lo + 1, column: offset - lineStarts[lo] + 1 };
+  };
+  const statements = parsed.program.body.filter(isNode);
+  const tops = statements.map(describeTopLevel);
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const readIn = /* @__PURE__ */ new Map();
+  const visit = (node2, stmt, insideFunction) => {
+    if (Array.isArray(node2)) {
+      for (const child of node2) visit(child, stmt, insideFunction);
+      return;
+    }
+    if (!isNode(node2)) return;
+    const type = node2.type;
+    if (type === "ImportDeclaration" || type === "ExportAllDeclaration") return;
+    if (type === "MetaProperty" || type === "PrivateIdentifier") return;
+    if (type === "ExportNamedDeclaration" && node2.source) return;
+    if (type.startsWith("TS")) {
+      if (TS_VALUE_WRAPPERS.has(type)) visit(node2.expression, stmt, insideFunction);
+      return;
+    }
+    if (type === "Identifier" || type === "IdentifierReference") {
+      const name = String(node2.name);
+      let readers = readIn.get(name);
+      if (!readers) readIn.set(name, readers = /* @__PURE__ */ new Set());
+      readers.add(stmt);
+      if (bound.has(name) || HOST_GLOBALS.has(name)) return;
+      const offset = typeof node2.start === "number" ? node2.start : 0;
+      const { line, column } = positionOf(offset);
+      const key = `${name}@${line}:${column}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      candidates.push({ name, line, column, enclosing: tops[stmt].label, stmt, insideFunction });
+      return;
+    }
+    const nowInsideFunction = insideFunction || FUNCTION_TYPES2.has(type);
+    for (const key of Object.keys(node2)) {
+      if (key === "type" || key === "start" || key === "end") continue;
+      if (TYPE_KEYS.has(key)) continue;
+      if (key === "key" && node2.computed !== true) continue;
+      if (key === "property" && node2.computed !== true) continue;
+      if (key === "label") continue;
+      if (key === "exported") continue;
+      if (key === "imported") continue;
+      visit(node2[key], stmt, nowInsideFunction);
+    }
+  };
+  for (let i = 0; i < statements.length; i++) visit(statements[i], i, false);
+  return candidates.filter((c) => {
+    const top = tops[c.stmt];
+    if (!c.insideFunction || top.exported || !top.declaresOnlyFunctions || top.declared.size === 0) return true;
+    for (const name of top.declared) {
+      const readers = readIn.get(name);
+      if (readers && [...readers].some((i) => i !== c.stmt)) return true;
+    }
+    return false;
+  }).map(({ name, line, column, enclosing }) => ({ name, line, column, enclosing }));
+}
+
+// src/compiler/module-hoist.ts
+var marker = (id) => `/*@pmh:${id}@*/`;
+var MARKER_RE = /\/\*@pmh:(\d+)@\*\/\n?/g;
+var HOIST_MARKER_PROBE = /\/\*@pmh:\d+@\*\//;
+var DECL_RE = /^(?:const|let|var|function\*?)\s+([A-Za-z_$][\w$]*)/;
+var ALWAYS_LOCAL = /* @__PURE__ */ new Set(["_map", "_k", "_env"]);
+function declaredNames(text) {
+  const out = [];
+  for (const line of text.split("\n")) {
+    const m = DECL_RE.exec(line);
+    if (m) out.push(m[1]);
+  }
+  return out;
+}
+function createModuleHoist() {
+  const texts = [];
+  const claim = (decls) => decls.map((text) => {
+    const id = texts.length;
+    texts.push(text);
+    return marker(id);
+  });
+  const finalize = () => {
+    const nameTexts = /* @__PURE__ */ new Map();
+    const textCount = /* @__PURE__ */ new Map();
+    const textNames = /* @__PURE__ */ new Map();
+    const order = [];
+    for (const text of texts) {
+      const seen = textCount.get(text);
+      textCount.set(text, (seen ?? 0) + 1);
+      if (seen === void 0) {
+        order.push(text);
+        const names = declaredNames(text);
+        textNames.set(text, names);
+        for (const n of names) {
+          const s = nameTexts.get(n);
+          if (s) s.add(text);
+          else nameTexts.set(n, /* @__PURE__ */ new Set([text]));
+        }
+      }
+    }
+    const hoisted = new Set(
+      order.filter(
+        (text) => (textCount.get(text) ?? 0) >= 2 && textNames.get(text).length > 0 && textNames.get(text).every((n) => !ALWAYS_LOCAL.has(n) && nameTexts.get(n).size === 1)
+      )
+    );
+    for (; ; ) {
+      const localNames = [];
+      for (const [n, ts] of nameTexts) {
+        if (ts.size !== 1 || !hoisted.has([...ts][0])) localNames.push(n);
+      }
+      let changed = false;
+      for (const text of [...hoisted]) {
+        if (localNames.some((n) => new RegExp(`\\b${escapeName(n)}\\b`).test(text))) {
+          hoisted.delete(text);
+          changed = true;
+        }
+      }
+      if (!changed) break;
     }
+    const preludeTexts = order.filter((t) => hoisted.has(t));
+    const prelude = preludeTexts.length === 0 ? "" : `${preludeTexts.join("\n")}
+`;
+    const removed = texts.reduce((n, t) => hoisted.has(t) ? n + t.length + 1 : n, 0);
+    return {
+      prelude,
+      savedBytes: removed - prelude.length,
+      hoistedNames: preludeTexts.flatMap((t) => textNames.get(t)),
+      resolve: (src) => src.replace(MARKER_RE, (m, idStr) => {
+        const text = texts[Number(idStr)];
+        if (text === void 0) throw new Error(`parseman: unknown hoist marker ${m}`);
+        if (hoisted.has(text)) return "";
+        return m.endsWith("\n") ? `${text}
+` : text;
+      })
+    };
   };
+  return { claim, finalize };
+}
+function escapeName(n) {
+  return n.replace(/\$/g, "\\$");
 }
 
 // src/plugin/index.ts
@@ -12942,7 +13285,7 @@ function parseModuleCached(filePath) {
   let parsed = null;
   try {
     const src = fs2.readFileSync(filePath, "utf8");
-    const r = parseSync3(filePath, src);
+    const r = parseSync4(filePath, src);
     if (r.errors.length === 0) parsed = { body: r.program.body, src };
   } catch {
   }
@@ -13083,7 +13426,7 @@ function lowerPrivateSourceModule(file, moduleAliases, warnUnloweredRegex, recov
     const source = fs2.readFileSync(file, "utf8");
     const transformed = transformMacro(source, file, moduleAliases, warnUnloweredRegex, recovery);
     if (!transformed || transformed.warnings.length > 0) return null;
-    const parsed = parseSync3(file, transformed.code);
+    const parsed = parseSync4(file, transformed.code);
     parsedModule = parsed.errors.length === 0 ? { body: parsed.program.body, src: transformed.code } : null;
     return parsedModule;
   } catch {
@@ -13107,7 +13450,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
 function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recovery, grammarCoverage) {
   let result;
   try {
-    result = parseSync3(id, code);
+    result = parseSync4(id, code);
   } catch {
     return null;
   }
@@ -13164,7 +13507,8 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       }
     }
   }
-  setReducerResolver(createReducerResolver(id, body, code));
+  const reducerResolver = createReducerResolver(id, body, code);
+  setReducerResolver(reducerResolver, code);
   const topLevelFunction = (moduleBody, name) => {
     for (const st of moduleBody) {
       const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
@@ -13259,15 +13603,18 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
       scope: factoryScope,
       imported: true
     });
+    reducerResolver.register(file);
   }
   const scope = /* @__PURE__ */ new Map();
   const replacements = [];
   const warnings = [];
+  const moduleHoist = grammarCoverage ? void 0 : createModuleHoist();
   beginLoweringCapture();
   beginInlineCapCapture();
   beginDegradationCapture();
   let anyUnresolved = false;
   let keepMacroImport = false;
+  const exportedFactories = [];
   let runtimeComposeFallback = false;
   let ruleMapHolderCounter = 0;
   const lineOf = (pos) => {
@@ -13626,7 +13973,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     const pieces = materializeCarried(carried, composing, false, cHostMode);
     try {
       return {
-        replacement: emitFusedSource(pieces),
+        replacement: emitFusedSource(pieces, moduleHoist),
         carried,
         ...composing ? { trivia: composing } : {},
         ...importedFactories.length ? { importedFactories } : {}
@@ -13694,7 +14041,7 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
         warn(init.start, "composeLeaf(): every pre-final grammar must explicitly prove recognition-only");
         return null;
       }
-      const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece]));
+      const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece], moduleHoist));
       return {
         replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement, `${id} composeLeaf()`)),
         ...importedFactories.length ? { importedFactories } : {}
@@ -13879,7 +14226,10 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
             scope.set(varName, staticValue);
             continue;
           }
-          if (factoryDecls.has(varName)) continue;
+          if (factoryDecls.has(varName)) {
+            if (exportPrefix) exportedFactories.push({ name: varName, pos: init.start });
+            continue;
+          }
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
         }
@@ -13950,6 +14300,14 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
   for (const imp of macroImports) {
     imp.fullyResolved = !anyUnresolved && !keepMacroImport;
   }
+  if (exportedFactories.length > 0 && macroImports.some((imp) => imp.fullyResolved)) {
+    const which = exportedFactories.map((f) => `  - ${id}:${lineOf(f.pos)} \u2014 export const ${f.name}`).join("\n");
+    throw new Error(
+      `${id} \u2014 a rules() factory cannot be exported; lowering leaves its body verbatim, so the export would ship a binding that throws ReferenceError on first call:
+${which}
+  Drop the \`export\`. The factory is macro-only; \`rules(${exportedFactories[0].name})\` is lowered in place and needs no runtime value.`
+    );
+  }
   const ms = new MagicString(code);
   const replacementRanges = runtimeComposeFallback ? [] : replacements.map(({ start, end }) => ({ start, end }));
   const isInsideReplacement = (start, end) => replacementRanges.some((r) => start >= r.start && end <= r.end);
@@ -13998,8 +14356,21 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
     }
   }
   const applied = runtimeComposeFallback ? [] : replacements;
+  const hoisted = applied.length > 0 ? moduleHoist?.finalize() : void 0;
   for (const { start, end, replacement } of applied.slice().sort((a, b) => b.start - a.start)) {
-    ms.overwrite(start, end, replacement);
+    ms.overwrite(start, end, hoisted ? hoisted.resolve(replacement) : replacement);
+  }
+  if (hoisted !== void 0 && hoisted.prelude !== "") {
+    const claiming = applied.filter((r) => HOIST_MARKER_PROBE.test(r.replacement));
+    if (claiming.length === 0) {
+      throw new Error(`${id} \u2014 internal: a module-hoist prelude was produced but no applied replacement carries a hoist marker`);
+    }
+    const firstStart = Math.min(...claiming.map((r) => r.start));
+    const anchor = body.find((s) => s.start <= firstStart && firstStart < s.end);
+    if (anchor === void 0) {
+      throw new Error(`${id} \u2014 internal: no top-level statement encloses macro replacement at ${firstStart}`);
+    }
+    ms.appendLeft(anchor.start, hoisted.prelude);
   }
   if (applied.length > 0) {
     ms.prepend(
@@ -14009,6 +14380,21 @@ function transformMacroImpl(code, id, moduleAliases, warnUnloweredRegex, recover
 `
     );
   }
+  if (applied.length > 0) {
+    let sourceFree = null;
+    const freeInSource = () => sourceFree ??= new Set(findFreeIdentifiers(code, id).map((f) => f.name));
+    const free = findFreeIdentifiers(ms.toString(), id).filter((f) => !freeInSource().has(f.name));
+    if (free.length > 0) {
+      const macroProvided = free.filter((f) => allNames.has(f.name));
+      const where = (f) => `  - ${id}:${f.line}:${f.column} \u2014 \`${f.name}\`` + (f.enclosing ? `, inside \`${f.enclosing}\`` : "");
+      const cause = macroProvided.length > 0 ? `
+  ${macroProvided.length === free.length ? "All" : `${macroProvided.length}`} of these came from the \`with { type: 'macro' }\` import, which was removed because every macro declaration lowered. Something still names them verbatim \u2014 a declaration parseman left as text rather than compiling. Make that declaration macro-buildable, or stop exporting it so lowering can drop it.` : "";
+      throw new Error(
+        `${id} \u2014 parseman will not emit this module: ${free.length} identifier(s) are read but bound by nothing, so it would throw ReferenceError at runtime (positions are in the EMITTED module):
+${free.map(where).join("\n")}${cause}`
+      );
+    }
+  }
   for (const line of formatInlineCapSites(endInlineCapCapture(), resolveInlineMax())) warnings.push(`${id}: ${line}`);
   const unlowered = endLoweringCapture();
   if (warnUnloweredRegex) {