parseman 0.42.0 → 0.43.0

package/dist/plugin/index.js

@@ -2742,6 +2742,191 @@ function markUnusedValues(root) {
   visit(resolveRoot(root), true);
 }
 
+// src/combinators/grammar.ts
+function annotateResultLines(result, index) {
+  const annotated = { ...result, span: annotateSpan(result.span, index) };
+  const errors = annotated.errors;
+  if (errors) {
+    ;
+    annotated.errors = errors.map((error) => ({
+      ...error,
+      span: annotateSpan(error.span, index)
+    }));
+  }
+  return annotated;
+}
+function createParseLineContext(input, pos) {
+  const lineIndex = createLineIndex();
+  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
+  return { lineIndex, lineScannedTo: pos };
+}
+function parser(opts, root) {
+  const clearTrivia = opts.trivia === null;
+  return {
+    _tag: "grammar",
+    _meta: root._meta,
+    _def: {
+      tag: "grammar",
+      parser: root,
+      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
+      clearTrivia,
+      ...opts.captureTrivia ? { captureTrivia: true } : {},
+      trackLines: opts.trackLines ?? false
+    },
+    parse(input, pos, _ctx) {
+      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
+      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
+      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
+      const ctx = {
+        ..._ctx,
+        trackLines,
+        ...lineIndex ? { _lineIndex: lineIndex } : {},
+        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
+        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
+        ...clearTrivia ? {
+          trivia: void 0,
+          triviaKindLabels: void 0
+        } : opts.trivia != null ? {
+          trivia: opts.trivia,
+          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
+        } : {},
+        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
+        // Kind-filter for per-node capture. Resolve against this scope's trivia
+        // labels — this parser's own trivia if it declares one, else the INHERITED
+        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
+        // trivia is inherited rather than re-declared here. No labels → undefined
+        // (capture all).
+        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
+      };
+      const result = root.parse(input, pos ?? 0, ctx);
+      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
+        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
+      }
+      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
+    }
+  };
+}
+function noTrivia(root) {
+  return parser({ trivia: null }, root);
+}
+
+// src/cst/reflection.ts
+var GRAMMAR_REFLECTION = /* @__PURE__ */ Symbol.for("parseman.grammarReflection");
+function childrenOf(def) {
+  switch (def.tag) {
+    case "sequence":
+    case "choice":
+      return def.parsers;
+    case "dispatch":
+      return [
+        def.selector,
+        ...def.cases.map((c) => c.parser),
+        ...def.matchers ? def.matchers.map((c) => c.parser) : [],
+        ...def.otherwise ? [def.otherwise] : []
+      ];
+    case "many":
+    case "oneOrMore":
+    case "optional":
+    case "attempt":
+    case "transform":
+    case "trivia":
+    case "token":
+    case "leaf":
+    case "label":
+    case "field":
+    case "not":
+    case "peek":
+    case "node":
+    case "withCtx":
+    case "recover":
+    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 "literal":
+    case "regex":
+    case "keywords":
+    case "routed":
+    case "guard":
+    case "lazy":
+    case "unknown":
+      return [];
+  }
+}
+function addNode(out, def) {
+  if (def.type === void 0) return;
+  const existing = out.get(def.type);
+  if (existing === void 0) {
+    out.set(def.type, def.tags === void 0 ? [] : [...def.tags]);
+    return;
+  }
+  if (def.tags === void 0) return;
+  for (const tag of def.tags) {
+    if (!existing.includes(tag)) existing.push(tag);
+  }
+}
+function collectFromCombinator(parser2, out, seen, followLazy = true) {
+  if (seen.has(parser2)) return;
+  seen.add(parser2);
+  const def = parser2._def;
+  if (def.tag === "lazy") {
+    if (followLazy) {
+      try {
+        collectFromCombinator(def.thunk(), out, seen, followLazy);
+      } catch {
+      }
+    }
+    return;
+  }
+  if (def.tag === "node") addNode(out, def);
+  for (const child of childrenOf(def)) collectFromCombinator(child, out, seen, followLazy);
+}
+function collectGrammarReflection(ruleMap, opts) {
+  const byType = /* @__PURE__ */ new Map();
+  const followLazy = opts?.followLazy !== false;
+  for (const [, rule] of ruleMap) {
+    if (!followLazy && rule._def.tag === "lazy") {
+      try {
+        const resolved = rule._def.thunk();
+        if (resolved._def.tag !== "lazy") collectFromCombinator(resolved, byType, /* @__PURE__ */ new Set(), false);
+      } catch {
+      }
+      continue;
+    }
+    collectFromCombinator(rule, byType, /* @__PURE__ */ new Set(), followLazy);
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function mergeGrammarReflections(reflections) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const reflection of reflections) {
+    for (const node2 of reflection.nodes) {
+      const tags = byType.get(node2.type);
+      if (tags === void 0) {
+        byType.set(node2.type, [...node2.tags]);
+        continue;
+      }
+      for (const tag of node2.tags) {
+        if (!tags.includes(tag)) tags.push(tag);
+      }
+    }
+  }
+  return { nodes: [...byType].map(([type, tags]) => ({ type, tags })) };
+}
+function attachGrammarReflection(grammar, reflection) {
+  Object.defineProperty(grammar, GRAMMAR_REFLECTION, { value: reflection, enumerable: false, configurable: true });
+  return grammar;
+}
+function grammarReflectionSource(reflection) {
+  return `{ nodes: ${JSON.stringify(reflection.nodes)} }`;
+}
+
 // src/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2817,6 +3002,21 @@ function rules(a, b) {
       if (rule && !rule._meta.isTrivia) rule._meta.grammarHostMode = "cst";
     }
   }
+  if (options?.trackLines === true) {
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia) rule._meta.grammarTrackLines = true;
+    }
+    for (const key of Object.keys(definitions)) {
+      const rule = cache[key];
+      if (rule && !rule._meta.isTrivia && rule._def.tag !== "grammar") {
+        const wrapped = parser({ trackLines: true }, rule);
+        tagRule(wrapped, key);
+        wrapped._meta.grammarTrackLines = true;
+        cache[key] = wrapped;
+      }
+    }
+  }
   for (const key of Object.keys(definitions)) {
     markUnusedValues(cache[key]);
   }
@@ -2825,6 +3025,7 @@ function rules(a, b) {
     enumerable: false,
     configurable: true
   });
+  attachGrammarReflection(cache, collectGrammarReflection(Object.keys(definitions).map((key) => [key, cache[key]])));
   return cache;
 }
 
@@ -3145,13 +3346,14 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
   const collapse = opts?.collapse === true;
   const captureTrivia = opts?.captureTrivia === true;
   const trailingTrivia = opts?.trailingTrivia === true;
+  const tags = opts?.tags;
   if (unwrap && collapse) {
     throw new Error("node() options cannot set both unwrap and collapse");
   }
   if (project !== void 0 && (unwrap || collapse)) {
     throw new Error("node() options cannot combine project with unwrap or collapse");
   }
-  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {} } : baseDef;
+  const def = unwrap || collapse || project !== void 0 || captureTrivia || trailingTrivia || tags !== void 0 && tags.length > 0 ? { ...baseDef, ...unwrap ? { unwrap: true } : {}, ...collapse ? { collapse: true } : {}, ...project !== void 0 ? { project } : {}, ...captureTrivia ? { captureTrivia: true } : {}, ...trailingTrivia ? { trailingTrivia: true } : {}, ...tags !== void 0 && tags.length > 0 ? { tags } : {} } : baseDef;
   const capturesTrivia = captureTrivia || trailingTrivia || (build ? buildReadsTrivia(def) : project === void 0);
   const clonesState = build ? buildReadsState(def) : project === void 0;
   const hasOwnFields = parserHasOwnFields(combinator);
@@ -3197,7 +3399,7 @@ function node(typeOrCombinator, combinatorOrBuild, buildOrOpts, maybeOpts) {
       const cstOutput = cstOutputHost(ctx.build);
       const span = ctx.trackLines ? annotateSpanFromLineContext(r.span, ctx) : r.span;
       const hostState = clonesState ? st : ctx.state !== void 0 ? Object.assign({}, ctx.state) : void 0;
-      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
+      const built = unwrap && children2.length === 1 ? unwrapChild(children2[0]) : collapse && children2.length === 1 ? children2[0] : !build && project === void 0 && ctx.build?._parsemanCstCollapse && children2.length === 1 && rawChildren.length === 1 && ctx.build._parsemanCstCollapse(nodeType, children2[0], children2, rawChildren) ? children2[0] : project !== void 0 ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : projectChild(children2, project, nodeType) : build ? cstOutput && ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, hostState, tags) : build(children2, fields, span, rawChildren, triviaLog, st) : ctx.build ? ctx.build(nodeType, children2, fields, span, rawChildren, triviaLog, st, tags) : { _tag: "node", type: nodeType, span: ctx.trackLines ? { ...span } : { start: r.span.start, end: r.span.end }, state: st ?? null, children: children2 };
       const rawEntry = isCstChild(built) ? built : { _tag: "leaf", value: typeof built === "string" ? built : typeof built === "object" && built !== null ? input.slice(r.span.start, r.span.end) : "", span };
       if (saved.buf !== void 0 || saved.ch !== void 0) {
         pushCstChild(ctx, built, rawEntry);
@@ -3273,74 +3475,6 @@ function field(name, combinator) {
   };
 }
 
-// src/combinators/grammar.ts
-function annotateResultLines(result, index) {
-  const annotated = { ...result, span: annotateSpan(result.span, index) };
-  const errors = annotated.errors;
-  if (errors) {
-    ;
-    annotated.errors = errors.map((error) => ({
-      ...error,
-      span: annotateSpan(error.span, index)
-    }));
-  }
-  return annotated;
-}
-function createParseLineContext(input, pos) {
-  const lineIndex = createLineIndex();
-  if (pos > 0) recordLineRange(lineIndex, input, 0, pos);
-  return { lineIndex, lineScannedTo: pos };
-}
-function parser(opts, root) {
-  const clearTrivia = opts.trivia === null;
-  return {
-    _tag: "grammar",
-    _meta: root._meta,
-    _def: {
-      tag: "grammar",
-      parser: root,
-      triviaParser: clearTrivia ? void 0 : opts.trivia ?? void 0,
-      clearTrivia,
-      ...opts.captureTrivia ? { captureTrivia: true } : {},
-      trackLines: opts.trackLines ?? false
-    },
-    parse(input, pos, _ctx) {
-      const trackLines = opts.trackLines ?? _ctx?.trackLines ?? false;
-      const lineContext = trackLines && _ctx?._lineIndex === void 0 && _ctx?._lineStarts === void 0 ? createParseLineContext(input, pos ?? 0) : void 0;
-      const lineIndex = trackLines ? _ctx?._lineIndex ?? (_ctx?._lineStarts ? { lineStarts: _ctx._lineStarts } : lineContext.lineIndex) : void 0;
-      const ctx = {
-        ..._ctx,
-        trackLines,
-        ...lineIndex ? { _lineIndex: lineIndex } : {},
-        ...lineContext ? { _lineScannedTo: lineContext.lineScannedTo } : {},
-        // trivia: null clears (contiguous terms); a Combinator sets; undefined inherits.
-        ...clearTrivia ? {
-          trivia: void 0,
-          triviaKindLabels: void 0
-        } : opts.trivia != null ? {
-          trivia: opts.trivia,
-          ...opts.trivia._meta.triviaKindLabels ? { triviaKindLabels: opts.trivia._meta.triviaKindLabels } : {}
-        } : {},
-        ...opts.captureTrivia || _ctx?.captureTrivia ? { captureTrivia: true } : {},
-        // Kind-filter for per-node capture. Resolve against this scope's trivia
-        // labels — this parser's own trivia if it declares one, else the INHERITED
-        // labels (`_ctx.triviaKindLabels`), so captureTriviaKinds still applies when
-        // trivia is inherited rather than re-declared here. No labels → undefined
-        // (capture all).
-        ...opts.captureTriviaKinds && !clearTrivia ? { _triviaCaptureMask: triviaKindMask(opts.trivia?._meta.triviaKindLabels ?? _ctx?.triviaKindLabels, opts.captureTriviaKinds) } : {}
-      };
-      const result = root.parse(input, pos ?? 0, ctx);
-      if (trackLines && _ctx && ctx._lineScannedTo !== void 0) {
-        _ctx._lineScannedTo = Math.max(_ctx._lineScannedTo ?? 0, ctx._lineScannedTo);
-      }
-      return lineIndex ? annotateResultLines(result, normalizeLineIndex(lineIndex)) : result;
-    }
-  };
-}
-function noTrivia(root) {
-  return parser({ trivia: null }, root);
-}
-
 // src/combinators/token.ts
 function token(root) {
   const meta = {
@@ -3437,7 +3571,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.42.0";
+var PARSEMAN_VERSION = "0.43.0";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -3503,7 +3637,7 @@ var SUGGESTIONS = {
 function classifyBroadArm(arm, resolve2) {
   const seen = /* @__PURE__ */ new Set();
   const relabel = (inner, cause, detail) => ({ cause, detail, ...inner?.unresolvedExternal ? { unresolvedExternal: true } : {} });
-  const walk2 = (p) => {
+  const walk = (p) => {
     if (seen.has(p)) return { cause: "ref-cycle", detail: "ref cycle" };
     seen.add(p);
     const d = p._def;
@@ -3517,7 +3651,7 @@ function classifyBroadArm(arm, resolve2) {
       // peek() CARRIES its body's first-set, so it is only broad when the body is
       // (or the body is nullable) — walk in for the real cause.
       case "peek":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "scanTo":
         return { cause: "broad-recognizer", detail: "scanTo (any first char)" };
       // `guard` (the `gate()` state predicate) has a genuinely-`any` first-set of
@@ -3531,7 +3665,7 @@ function classifyBroadArm(arm, resolve2) {
       case "attempt":
       case "withCtx":
       case "recover":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "lazy": {
         const name = p._ruleName;
         let target;
@@ -3543,13 +3677,13 @@ function classifyBroadArm(arm, resolve2) {
             return { cause: "cross-artifact-ref", detail: `unresolved ref${name ? ` g.${name}` : ""}`, unresolvedExternal: name !== void 0 };
           target = bound;
         }
-        const inner = walk2(target);
+        const inner = walk(target);
         if (name !== void 0) return inner ? relabel(inner, "cross-artifact-ref", `via ref g.${name} \u2192 ${inner.detail}`) : null;
         return inner;
       }
       case "optional":
       case "many": {
-        const inner = walk2(d.parser);
+        const inner = walk(d.parser);
         return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
       }
       case "oneOrMore":
@@ -3562,9 +3696,9 @@ function classifyBroadArm(arm, resolve2) {
       case "node":
       case "grammar":
       case "expect":
-        return walk2(d.parser);
+        return walk(d.parser);
       case "skip":
-        return walk2(d.main);
+        return walk(d.main);
       case "sequence": {
         let sawNullablePrefix = false;
         for (const t of d.parsers) {
@@ -3573,7 +3707,7 @@ function classifyBroadArm(arm, resolve2) {
             continue;
           }
           if (isAny(firstSetOf(t, /* @__PURE__ */ new Set(), resolve2))) {
-            const inner = walk2(t);
+            const inner = walk(t);
             if (sawNullablePrefix)
               return relabel(inner, "nullable-prefix", inner ? `nullable prefix \u2192 ${inner.detail}` : "nullable prefix to broad term");
             return inner ?? { cause: "broad-recognizer", detail: "sequence leading term is broad" };
@@ -3588,18 +3722,18 @@ function classifyBroadArm(arm, resolve2) {
       }
       case "choice": {
         for (const a of d.parsers) {
-          const r = walk2(a);
+          const r = walk(a);
           if (r) return relabel(r, r.cause, `choice arm \u2192 ${r.detail}`);
         }
         return null;
       }
       case "dispatch":
-        return walk2(d.selector);
+        return walk(d.selector);
       default:
         return { cause: "broad-recognizer", detail: `unmodeled construct (${d.tag})` };
     }
   };
-  return walk2(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
+  return walk(arm) ?? { cause: "broad-recognizer", detail: "broad (cause not localized)" };
 }
 function peelToLeading(arm) {
   let d = arm._def;
@@ -3801,7 +3935,7 @@ function formatGatingWarnings(report) {
 
 // src/analysis/duplication.ts
 var siteToString = (s) => s.path === "" ? s.rule : `${s.rule} \u203A ${s.path}`;
-function childrenOf(d) {
+function childrenOf2(d) {
   switch (d.tag) {
     case "sequence":
     case "choice":
@@ -3935,7 +4069,7 @@ function render(p, depth = 3) {
       break;
   }
   if (depth <= 0) return `${d.tag}(\u2026)`;
-  const kids = childrenOf(d).map((k) => render(k, depth - 1));
+  const kids = childrenOf2(d).map((k) => render(k, depth - 1));
   switch (d.tag) {
     case "sequence":
       return `sequence(${kids.join(", ")})`;
@@ -4130,7 +4264,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     const d = p._def;
     shapeCache.set(p, interner.hole);
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const id = interner.of(`${payloadKey(p, d)}|${kids.map(shapeOf).join(",")}`);
     shapeCache.set(p, id);
     return id;
@@ -4140,7 +4274,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     if (hit !== void 0) return hit;
     sizeCache.set(p, 1);
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     sizeCache.set(p, n);
     return n;
   };
@@ -4153,7 +4287,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
     visited.set(p, { p, d, site: here, shape: shapeOf(p), size: sizeOf(p), enclosingNode, enclosingReducer });
     const inner = d.tag === "node" ? d.type ?? "(anonymous)" : enclosingNode;
     const innerReducer = enclosingReducer || d.tag === "node" && (d.build !== void 0 || d.buildSrc !== void 0) || d.tag === "transform" || d.tag === "leaf";
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     kids.forEach((k, i) => {
       const seg = segment(d, i);
       visit(k, here.rule, here.path === "" ? seg : `${here.path} \u203A ${seg}`, inner, innerReducer);
@@ -4213,7 +4347,7 @@ function analyzeDuplicationRules(ruleMap, opts) {
 function markSubtree(p, into) {
   if (into.has(p)) return;
   into.add(p);
-  for (const k of childrenOf(p._def)) markSubtree(k, into);
+  for (const k of childrenOf2(p._def)) markSubtree(k, into);
 }
 var stripMembers = (f) => {
   const { _members, ...rest } = f;
@@ -4253,7 +4387,7 @@ function findNearDuplicates(visited, interner, shapeOf, minSize) {
     if (hit !== void 0) return hit;
     holeCache.set(p, []);
     const d = p._def;
-    const kids = childrenOf(d);
+    const kids = childrenOf2(d);
     const kidShapes = kids.map(shapeOf);
     const payload = payloadKey(p, d);
     const out2 = [];
@@ -4314,7 +4448,7 @@ function findDivergentSlot(members, shapeOf) {
   let cur = [...members];
   for (let guard2 = 0; guard2 < 64; guard2++) {
     const d0 = cur[0]._def;
-    const kidLists = cur.map((c) => childrenOf(c._def));
+    const kidLists = cur.map((c) => childrenOf2(c._def));
     const arity = kidLists[0].length;
     if (kidLists.some((k) => k.length !== arity) || arity === 0) break;
     const diff = [];
@@ -4327,7 +4461,7 @@ function findDivergentSlot(members, shapeOf) {
     path2.push(i);
     defs.push(d0);
     cur = kidLists.map((k) => k[i]);
-    const nextArity = childrenOf(cur[0]._def).length;
+    const nextArity = childrenOf2(cur[0]._def).length;
     const samePayload = cur.every((c) => payloadKey(c, c._def) === payloadKey(cur[0], cur[0]._def));
     if (!samePayload || nextArity === 0) break;
   }
@@ -4335,7 +4469,7 @@ function findDivergentSlot(members, shapeOf) {
   let slotSize = 0;
   const sizeOf = (p) => {
     let n = 1;
-    for (const k of childrenOf(p._def)) n += sizeOf(k);
+    for (const k of childrenOf2(p._def)) n += sizeOf(k);
     return n;
   };
   for (const c of cur) slotSize = Math.max(slotSize, sizeOf(c));
@@ -4344,7 +4478,7 @@ function findDivergentSlot(members, shapeOf) {
 function renderWithHole(p, path2, depth = 0) {
   if (depth === path2.length) return "\u2039slot\u203A";
   const d = p._def;
-  const kids = childrenOf(d);
+  const kids = childrenOf2(d);
   const idx = path2[depth];
   const parts = kids.map((k, i) => i === idx ? renderWithHole(k, path2, depth + 1) : render(k, 2));
   switch (d.tag) {
@@ -4802,7 +4936,7 @@ function capturesPositionally(p, seen = /* @__PURE__ */ new Set()) {
   seen.add(p);
   const d = p._def;
   if (d.tag === "field" || d.tag === "label") return true;
-  for (const k of childrenOf(d)) if (capturesPositionally(k, seen)) return true;
+  for (const k of childrenOf2(d)) if (capturesPositionally(k, seen)) return true;
   return false;
 }
 function detectHandRolledSepBy(terms, shapeOf) {
@@ -4908,7 +5042,7 @@ function nestedNodeTypes(root, out, seen, isRoot) {
     }
     return;
   }
-  for (const k of childrenOf(d)) nestedNodeTypes(k, out, seen, false);
+  for (const k of childrenOf2(d)) nestedNodeTypes(k, out, seen, false);
 }
 var MAX_LOST_TYPES = 8;
 function findStructureLoss(visited, resolve2) {
@@ -6805,13 +6939,16 @@ function reindentStmts(stmts, targetLevels) {
   const targetPrefix = "  ".repeat(targetLevels);
   return stmts.map((s) => s.trim().length === 0 ? "" : targetPrefix + s.slice(minLeading));
 }
-function failReturn(expected, posExpr) {
+function failReturn(ctx, expected, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [${expected}], span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: [${expected}], span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function failReturnArr(expectedArr, posExpr) {
+function failReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: ${expectedArr}, span: ${emitSpanExpr(ctx, posExpr, posExpr)} }`;
   return `return { ok: false, expected: ${expectedArr}, span: { start: ${posExpr}, end: ${posExpr} } }`;
 }
-function committedReturnArr(expectedArr, posExpr) {
+function committedReturnArr(ctx, expectedArr, posExpr) {
+  if (ctx.lineTracking) return `return { ok: false, expected: [...${expectedArr}], span: ${emitSpanExpr(ctx, posExpr, posExpr)}, committed: true }`;
   return `return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} }, committed: true }`;
 }
 function hoistExpected(ctx, constArrSource) {
@@ -6836,7 +6973,7 @@ function failBody(ctx, expected, posExpr) {
     if (!ctx.recordFail) return probe ? `{ ${probe}${trace}break ${ctx.failLabel} }` : trace ? `{ ${trace}break ${ctx.failLabel} }` : `break ${ctx.failLabel}`;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${hoistExpected(ctx, `[${expected}]`)}; ${trace}break ${ctx.failLabel} }`;
   }
-  return probe + trace + failReturn(expected, posExpr);
+  return probe + trace + failReturn(ctx, expected, posExpr);
 }
 function failArrBody(ctx, expectedArr, posExpr, constant = true) {
   const probe = probeUpdate(ctx, expectedArr, posExpr, constant);
@@ -6846,18 +6983,19 @@ function failArrBody(ctx, expectedArr, posExpr, constant = true) {
     const fx = constant ? hoistExpected(ctx, expectedArr) : expectedArr;
     return `{ ${probe}_ctx._fe = ${posExpr}; _ctx._fx = ${fx}; ${trace}break ${ctx.failLabel} }`;
   }
-  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: { start: ${posExpr}, end: ${posExpr} } }`;
-  return probe + trace + failReturnArr(expectedArr, posExpr);
+  if (!constant) return `${probe}${trace}return { ok: false, expected: [...${expectedArr}], span: ${ctx.lineTracking ? emitSpanExpr(ctx, posExpr, posExpr) : `{ start: ${posExpr}, end: ${posExpr} }`} }`;
+  return probe + trace + failReturnArr(ctx, expectedArr, posExpr);
 }
-function resultFromRecorded(feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
-  return `return { ok: false, expected: [...${fxExpr}], span: { start: ${feExpr}, end: ${feExpr} }, ...(_ctx._fc ? { committed: true } : {}) }`;
+function resultFromRecorded(ctx, feExpr = "_ctx._fe", fxExpr = "_ctx._fx") {
+  const spanExpr = ctx.lineTracking ? emitSpanExpr(ctx, feExpr, feExpr) : `{ start: ${feExpr}, end: ${feExpr} }`;
+  return `return { ok: false, expected: [...${fxExpr}], span: ${spanExpr}, ...(_ctx._fc ? { committed: true } : {}) }`;
 }
 function committedFailBody(ctx, expectedArr = "_ctx._fx", posExpr = "_ctx._fe") {
   if (ctx.failLabel) {
     if (!ctx.recordFail) return `{ _ctx._fc = true; break ${ctx.failLabel} }`;
     return `{ _ctx._fc = true; _ctx._fe = ${posExpr}; _ctx._fx = ${expectedArr}; break ${ctx.failLabel} }`;
   }
-  return committedReturnArr(expectedArr, posExpr);
+  return committedReturnArr(ctx, expectedArr, posExpr);
 }
 function propagateFailBody(ctx, srcCtx = "_ctx") {
   if (srcCtx !== "_ctx") {
@@ -6865,10 +7003,10 @@ function propagateFailBody(ctx, srcCtx = "_ctx") {
       if (!ctx.recordFail) return `break ${ctx.failLabel}`;
       return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; break ${ctx.failLabel} }`;
     }
-    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded()} }`;
+    return `{ _ctx._fe = ${srcCtx}._fe; _ctx._fx = ${srcCtx}._fx; _ctx._fc = ${srcCtx}._fc; ${resultFromRecorded(ctx)} }`;
   }
   if (ctx.failLabel) return `break ${ctx.failLabel}`;
-  return resultFromRecorded();
+  return resultFromRecorded(ctx);
 }
 function emitIfFail(ctx, cond, body) {
   return [
@@ -8099,7 +8237,7 @@ function routedNeedsContextBridge(p, ctx, seen = /* @__PURE__ */ new Set()) {
   const d = p._def;
   if (d.tag === "dispatch") return false;
   if (d.tag === "withCtx") return parserUsesRouted2(d.parser);
-  return childrenOf2(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
+  return childrenOf3(d).some((child) => routedNeedsContextBridge(child, ctx, seen));
 }
 function armReplayInScope(arm, ctx) {
   let p = arm;
@@ -8301,7 +8439,7 @@ function emitAttempt(p, def, ctx, pos) {
   if (!ctx.recovery && !ctx.coverage && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_agc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(gExp, pos)} }`;
+    const gFail = ctx.failLabel ? `{ _ctx._fe = ${pos};${ctx.recordFail ? ` _ctx._fx = ${gExp};` : ""} break ${ctx.failLabel} }` : `{ _ctx._fe = ${pos}; ${failReturnArr(ctx, gExp, pos)} }`;
     preGuard.push(
       `${ind(ctx)}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${ind(ctx)}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -8800,7 +8938,7 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   if (!ctx.recovery && !ctx.coverage && (capturesChildren || structural) && needsFirstSetGuard(def.parser)) {
     const gcV = v(ctx, "_ngc");
     const gExp = armStaticExpected(ctx, def.parser);
-    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(gExp, pos);
+    const gFail = ctx.failLabel ? ctx.recordFail ? `{ _ctx._fe = ${pos}; _ctx._fx = ${gExp}; break ${ctx.failLabel} }` : `break ${ctx.failLabel}` : failReturnArr(ctx, gExp, pos);
     preGuard.push(
       `${i}const ${gcV} = ${pos} < input.length ? (input.codePointAt(${pos}) ?? -1) : -1`,
       `${i}if (!(${firstSetCond(gcV, def.parser._meta.firstSet)})) ${gFail}`
@@ -8862,7 +9000,8 @@ ${i}const ${chV} = ${chAlloc}, ${rawV} = ${profileRecognizer} ? undefined : [],
   const nodeSpanV = ctx.lineTracking ? v(ctx, "_nspan") : nodeSpanExpr;
   if (ctx.lineTracking) stmts.push(`${i}const ${nodeSpanV} = ${nodeSpanExpr}`);
   const buildExpr = structural ? `{ _tag: 'node', type: ${JSON.stringify(def.type)}, span: ${nodeSpanV}, state: ${stV} ?? null, children: ${chV} }` : mkType ? emitInlineMkNodeExpr(mkType, chV, rawV, nodeSpanV, tlV) : def.project !== void 0 ? emitNodeProjectExpr(def.type, def.project, chV) : `${buildRef(ctx)}[${buildIdx}](${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
-  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV})`;
+  const hostBuildArgs = `${JSON.stringify(def.type)}, ${chV}, ${fObj}, ${nodeSpanV}, ${rawV}, ${tlV}, ${stV}${def.tags !== void 0 && def.tags.length > 0 ? `, ${JSON.stringify(def.tags)}` : ""}`;
+  const hostBuildExpr = `_ctx._pmProfile?.phase === 'host' && _ctx._pmProfile.hostCalls++, _ctx.build(${hostBuildArgs})`;
   const ndExpr = structural ? `_ctx.build !== undefined ? (${hostBuildExpr}) : (${buildExpr})` : cstOut ? hostBuildExpr : buildExpr;
   const hostCollapseExpr = structural ? `_ctx.build !== undefined && _ctx.build._parsemanCstCollapse !== undefined && ${chV}.length === 1 && ${rawV}.length === 1 && _ctx.build._parsemanCstCollapse(${JSON.stringify(def.type)}, ${chV}[0], ${chV}, ${rawV}) ? ${chV}[0] : (${ndExpr})` : ndExpr;
   const unwrapExpr = `${chV}.length === 1 ? (${chV}[0] !== null && typeof ${chV}[0] === 'object' && ${chV}[0]._tag === 'leaf' ? ${chV}[0].value : ${chV}[0]) : (${ndExpr})`;
@@ -9316,6 +9455,7 @@ function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
   seen.add(p);
   const d = p._def;
+  if (p._meta.grammarTrackLines) return true;
   if (d.tag === "grammar" && d.trackLines) return true;
   if (d.tag === "lazy") {
     try {
@@ -9324,7 +9464,7 @@ function hasLineTrackingDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasLineTrackingDef(child, seen));
+  return childrenOf3(d).some((child) => hasLineTrackingDef(child, seen));
 }
 function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(p)) return false;
@@ -9343,7 +9483,7 @@ function parserUsesRouted2(p, seen = /* @__PURE__ */ new Set()) {
     case "dispatch":
       return false;
     default:
-      return childrenOf2(d).some((child) => parserUsesRouted2(child, seen));
+      return childrenOf3(d).some((child) => parserUsesRouted2(child, seen));
   }
 }
 function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
@@ -9358,9 +9498,9 @@ function hasDirectBuildDef(p, seen = /* @__PURE__ */ new Set()) {
       return false;
     }
   }
-  return childrenOf2(d).some((child) => hasDirectBuildDef(child, seen));
+  return childrenOf3(d).some((child) => hasDirectBuildDef(child, seen));
 }
-function childrenOf2(def) {
+function childrenOf3(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -9435,7 +9575,7 @@ function subtreeSizes(roots) {
     const def = p._def;
     let s = 1;
     if (def.tag !== "lazy") {
-      for (const child of childrenOf2(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
+      for (const child of childrenOf3(def)) s += child._def.tag === "lazy" ? 1 : sz(child);
     }
     sizes.set(p, s);
     return s;
@@ -9456,7 +9596,7 @@ function subtreeSizes(roots) {
       return;
     }
     sz(p);
-    for (const child of childrenOf2(def)) visit(child);
+    for (const child of childrenOf3(def)) visit(child);
   };
   for (const root of roots) visit(root);
   return sizes;
@@ -9466,7 +9606,7 @@ function analyzeLazyUsageMulti(roots) {
   const recursive = /* @__PURE__ */ new Set();
   const descended = /* @__PURE__ */ new Set();
   const active = /* @__PURE__ */ new Set();
-  function walk2(p) {
+  function walk(p) {
     const def = p._def;
     if (def.tag === "lazy") {
       counts.set(p, (counts.get(p) ?? 0) + 1);
@@ -9483,17 +9623,17 @@ function analyzeLazyUsageMulti(roots) {
         return;
       }
       active.add(p);
-      walk2(resolved);
+      walk(resolved);
       active.delete(p);
       return;
     }
     if (isHoistableTag(def.tag)) {
       counts.set(p, (counts.get(p) ?? 0) + 1);
     }
-    for (const child of childrenOf2(def)) walk2(child);
+    for (const child of childrenOf3(def)) walk(child);
   }
   const rootsArr = [...roots];
-  for (const root of rootsArr) walk2(root);
+  for (const root of rootsArr) walk(root);
   return { counts, recursive, sizes: subtreeSizes(rootsArr) };
 }
 function ruleDependencies(ruleMap) {
@@ -9503,7 +9643,7 @@ function ruleDependencies(ruleMap) {
   for (const [name, comb] of ruleMap) {
     const found = /* @__PURE__ */ new Set();
     const seen = /* @__PURE__ */ new Set();
-    const walk2 = (p, isRoot) => {
+    const walk = (p, isRoot) => {
       const def = p._def;
       const boundary = def.tag === "lazy" ? nameOf.get(p) ?? p._ruleName : nameOf.get(p);
       if (!isRoot && boundary !== void 0) {
@@ -9519,12 +9659,12 @@ function ruleDependencies(ruleMap) {
         } catch {
           return;
         }
-        walk2(resolved, false);
+        walk(resolved, false);
         return;
       }
-      for (const child of childrenOf2(def)) walk2(child, false);
+      for (const child of childrenOf3(def)) walk(child, false);
     };
-    walk2(comb, true);
+    walk(comb, true);
     deps.set(name, [...found]);
   }
   return deps;
@@ -9673,6 +9813,7 @@ function compile(combinator, mapFnSources, opts) {
   const grammarTrivia = combinator._meta.grammarTrivia;
   const grammarScanSkip = combinator._meta.grammarScanSkip;
   const grammarHostMode = combinator._meta.grammarHostMode;
+  const grammarTrackLines = combinator._meta.grammarTrackLines;
   const ctx = {
     vars: 0,
     indent: 1,
@@ -9693,7 +9834,7 @@ function compile(combinator, mapFnSources, opts) {
     capturing: hasNodeDef(combinator),
     recovery: opts?.recovery ?? false,
     hostMode: opts?.hostMode ?? grammarHostMode ?? "ast",
-    lineTracking: opts?.trackLines === true || hasLineTrackingDef(combinator),
+    lineTracking: opts?.trackLines === true || grammarTrackLines === true || hasLineTrackingDef(combinator),
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(combinator), entry: combinator } } : {},
     lazyUsage: analyzeLazyUsage(combinator),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -9857,6 +9998,7 @@ function compileRuleMap(ruleMap, opts) {
   const grammarTrivia = opts?.trivia;
   const grammarScanSkip = opts?.scanSkip ?? ruleMap.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMap.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
+  const grammarTrackLines = opts?.trackLines === true || ruleMap.some(([, r]) => r._meta.grammarTrackLines === true);
   const ctx = {
     vars: 0,
     indent: 1,
@@ -9877,6 +10019,7 @@ function compileRuleMap(ruleMap, opts) {
     capturing: ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
     hostMode: grammarHostMode ?? "ast",
+    lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: buildGrammarPlan(ruleMap.map(([, rule]) => rule), coverageWinners) } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ...grammarTrivia ? { activeTrivia: grammarTrivia, triviaKindLabels: grammarTrivia._meta.triviaKindLabels } : {},
@@ -9910,6 +10053,10 @@ function compileRuleMap(ruleMap, opts) {
   const mfCovered = ctx.mapFns.length === 0 || derivedSrcs !== void 0;
   const canInline = ctx.runtimeParsers.length === 0 && mfCovered && buildCovered;
   if (!canInline) return null;
+  if (ctx.lineTracking) {
+    ctx.needsLineTrack = true;
+    ctx.needsLineSpan = true;
+  }
   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() : [];
@@ -9939,15 +10086,23 @@ function compileRuleMap(ruleMap, opts) {
   };
   const entryFnText = (r, rule) => {
     const ruleId = entryRuleId(rule);
+    const linePreamble = ctx.lineTracking ? [
+      `  if (_ctx._lineStarts === undefined) _ctx = { ..._ctx, trackLines: true, _lineStarts: [0], _lineScannedTo: 0 }`,
+      `  else _ctx.trackLines = true`,
+      `  if (_pos > (_ctx._lineScannedTo ?? 0)) _trackLines(_ctx, input, 0, _pos)`
+    ] : [];
+    const resultSpan = ctx.lineTracking ? `_spanLines(_ctx, _pos, ${r.endVar})` : `{ start: _pos, end: ${r.endVar} }`;
     const body = ruleId === void 0 ? [
+      ...linePreamble,
       `  let pos = _pos`,
       ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`
+      `  return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`
     ] : [
+      ...linePreamble,
       `  const _coverageResult = (() => {`,
       `    let pos = _pos`,
       ...r.stmts,
-      `    return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `    return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`,
       `  })()`,
       `  if (!_coverageResult.ok) _ctx._grammarTrace?.write({ id: ${JSON.stringify(ruleId)}, phase: 'failure', offset: _coverageResult.span.start })`,
       `  return _coverageResult`
@@ -9974,6 +10129,7 @@ function compileRuleMap(ruleMap, opts) {
     // host check passes vacuously — see `withHostMode` in the plugin.
     hostMode: ctx.hostMode ?? "ast",
     hostBranchElided: !!ctx.hostBranchElided,
+    reflection: collectGrammarReflection(ruleMap),
     ...ctx.coverage === void 0 ? {} : { coverageDefinitions: ctx.coverage.plan.definitions }
   };
 }
@@ -9985,6 +10141,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
   const grammarTrivia = opts?.trivia ?? ruleMapArg.map(([, r]) => r._meta.grammarTrivia).find(Boolean);
   const grammarScanSkip = opts?.scanSkip ?? ruleMapArg.map(([, r]) => r._meta.grammarScanSkip).find(Boolean);
   const grammarHostMode = opts?.hostMode ?? ruleMapArg.map(([, r]) => r._meta.grammarHostMode).find(Boolean);
+  const grammarTrackLines = opts?.trackLines === true || ruleMapArg.some(([, r]) => r._meta.grammarTrackLines === true);
   const ruleMap = ruleMapArg.filter(([, val]) => {
     const d = val._def;
     if (d.tag !== "lazy") return true;
@@ -9995,6 +10152,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
       return false;
     }
   });
+  const nodeMeta = new Map(ruleMap.map(([name, rule]) => [name, collectGrammarReflection([[name, rule]], { followLazy: false })]));
   const ctx = {
     vars: 0,
     indent: 1,
@@ -10019,6 +10177,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     capturing: opts?.captureTerminals === true || ruleMap.some(([, rule]) => hasNodeDef(rule)),
     recovery: opts?.recovery ?? false,
     hostMode: grammarHostMode ?? "ast",
+    lineTracking: grammarTrackLines,
     ...opts?.coverage ? { coverage: { plan: opts.coverage } } : {},
     lazyUsage: analyzeLazyUsageMulti(ruleMap.map(([, rule]) => rule)),
     ns,
@@ -10069,7 +10228,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
         scanExternal(resolved);
         return;
       }
-      for (const child of childrenOf2(def)) scanExternal(child);
+      for (const child of childrenOf3(def)) scanExternal(child);
     };
     for (const [, rule] of ruleMap) scanExternal(rule);
   }
@@ -10115,6 +10274,10 @@ function compileLinkable(ruleMapArg, ns, opts) {
     perEntry.push({ key, rule, r: emitNamedFnCall(ctx, fn, "_pos") });
   }
   if (ctx.runtimeParsers.length !== 0) return null;
+  if (ctx.lineTracking) {
+    ctx.needsLineTrack = true;
+    ctx.needsLineSpan = true;
+  }
   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();
@@ -10128,6 +10291,8 @@ function compileLinkable(ruleMapArg, ns, opts) {
   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.needsLineTrack ? LINE_TRACK_DECL : "",
+    ctx.needsLineSpan ? LINE_SPAN_DECL : "",
     ...ctx.regexDecls,
     ...ctx.expectedDecls,
     mfDecl,
@@ -10136,11 +10301,18 @@ function compileLinkable(ruleMapArg, ns, opts) {
   ].filter(Boolean);
   const wrappers = /* @__PURE__ */ new Map();
   for (const { key, rule, r } of perEntry) {
+    const linePreamble = ctx.lineTracking ? [
+      `  if (_ctx._lineStarts === undefined) _ctx = { ..._ctx, trackLines: true, _lineStarts: [0], _lineScannedTo: 0 }`,
+      `  else _ctx.trackLines = true`,
+      `  if (_pos > (_ctx._lineScannedTo ?? 0)) _trackLines(_ctx, input, 0, _pos)`
+    ] : [];
+    const resultSpan = ctx.lineTracking ? `_spanLines(_ctx, _pos, ${r.endVar})` : `{ start: _pos, end: ${r.endVar} }`;
     wrappers.set(key, publicRuleWrapperSource(rule, [
       `function(input, _pos, _ctx) {`,
+      ...linePreamble,
       `  let pos = _pos`,
       ...r.stmts,
-      `  return { ok: true, value: ${r.valueVar}, span: { start: _pos, end: ${r.endVar} } }`,
+      `  return { ok: true, value: ${r.valueVar}, span: ${resultSpan} }`,
       `}`
     ].join("\n"), ctx.triviaKindLabels));
   }
@@ -10178,6 +10350,7 @@ function compileLinkable(ruleMapArg, ns, opts) {
     hostBranchElided: !!ctx.hostBranchElided,
     hasDirectBuilders: ruleMap.some(([, rule]) => hasDirectBuildDef(rule)),
     isRecognitionOnly: !hasSemanticReduction(ruleMap.map(([, rule]) => rule), externalRefs),
+    nodeMeta,
     mfFns: mfSrcs ? [] : ctx.mapFns,
     buildFns: buildSrcs ? [] : ctx.buildFns
   };
@@ -10198,7 +10371,7 @@ function hasExternalRuleRef(ruleMap) {
       if (resolved === void 0) return p._ruleName !== void 0;
       return visit(resolved);
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return ruleMap.some(([, rule]) => visit(rule));
 }
@@ -10220,7 +10393,7 @@ function hasSemanticReduction(roots, externalRefs) {
         return true;
       }
     }
-    return childrenOf2(def).some(visit);
+    return childrenOf3(def).some(visit);
   };
   return roots.some(visit);
 }
@@ -10293,7 +10466,7 @@ function withCtx(extra, combinator) {
 }
 
 // src/compiler/ir-serialize.ts
-function childrenOf3(def) {
+function childrenOf4(def) {
   switch (def.tag) {
     case "sequence":
     case "choice":
@@ -10357,6 +10530,10 @@ function projectOpt(project) {
   if (project === void 0) return void 0;
   return `project: ${project}`;
 }
+function tagsOpt(tags) {
+  if (tags === void 0 || tags.length === 0) return void 0;
+  return `tags: ${JSON.stringify(tags)}`;
+}
 function matcherExpr(entry) {
   switch (entry.kind) {
     case "startsWith":
@@ -10570,7 +10747,7 @@ var Serializer = class {
       if (target) this.assertNoRuleRef(target, seen);
       return;
     }
-    for (const child of childrenOf3(c._def)) this.assertNoRuleRef(child, seen);
+    for (const child of childrenOf4(c._def)) this.assertNoRuleRef(child, seen);
   }
   /** 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
@@ -10634,7 +10811,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
     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 childrenOf3(def)) this.analyze(child, active);
+    for (const child of childrenOf4(def)) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -10751,12 +10928,14 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       case "node": {
         if (def.build !== void 0 && def.buildSrc === void 0) throw new Unserializable("node build without buildSrc");
         const projectEntry = projectOpt(def.project);
+        const tagEntry = tagsOpt(def.tags);
         const optEntries = [
           ...def.unwrap ? ["unwrap: true"] : [],
           ...def.collapse ? ["collapse: true"] : [],
           ...projectEntry === void 0 ? [] : [projectEntry],
           ...def.captureTrivia ? ["captureTrivia: true"] : [],
-          ...def.trailingTrivia ? ["trailingTrivia: true"] : []
+          ...def.trailingTrivia ? ["trailingTrivia: true"] : [],
+          ...tagEntry === void 0 ? [] : [tagEntry]
         ];
         const opts = optEntries.length > 0 ? `, { ${optEntries.join(", ")} }` : "";
         if (def.type === void 0) {
@@ -10794,15 +10973,16 @@ function normalizeCstCollapse(collapse) {
   }
   return typeof collapse === "function" ? collapse : void 0;
 }
-function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state) {
-  return { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
+function buildCstNode(type, children2, _fields, span, _rawChildren, _triviaLog, state, tags) {
+  return tags !== void 0 && tags.length > 0 ? { _tag: "node", type, tags, span: { ...span }, state: state ?? null, children: [...children2] } : { _tag: "node", type, span: { ...span }, state: state ?? null, children: [...children2] };
 }
-function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state) {
+function cstBuildHost(typeOrOptions, children2, _fields, span, rawChildren, triviaLog, state, _tags) {
   if (typeof typeOrOptions === "string") {
     return buildCstNode(typeOrOptions, children2 ?? [], _fields, span ?? { start: 0, end: 0 }, rawChildren, triviaLog, state);
   }
   const collapse = normalizeCstCollapse(typeOrOptions?.collapse);
-  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2);
+  const materializeTags = typeOrOptions?.tags === true;
+  const host = (type, children3, fields, span2, rawChildren2, triviaLog2, state2, tags) => buildCstNode(type, children3 ?? [], fields, span2, rawChildren2, triviaLog2, state2, materializeTags ? tags : void 0);
   host._parsemanCstOutput = true;
   if (collapse) host._parsemanCstCollapse = collapse;
   return host;
@@ -10823,7 +11003,7 @@ function pickPieces(pieces, names) {
   };
   for (const n of names) visit(n);
   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) })).filter((pc) => pc.keys.length > 0);
+  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) {
   for (const p of pieces) {
@@ -10861,6 +11041,7 @@ function fusedBody(pieces) {
     ...[...winner].map(([k, p]) => p.ruleFns.get(k))
   ];
   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,
@@ -10869,6 +11050,7 @@ function fusedBody(pieces) {
     "}",
     `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_MODE.description)}), { value: ${JSON.stringify(mode)}, enumerable: false })`,
     `Object.defineProperty(_map, Symbol.for(${JSON.stringify(FUSED_HOST_ELIDED.description)}), { value: ${JSON.stringify(elided)}, enumerable: false })`,
+    `Object.defineProperty(_map, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`,
     // …and on each rule FUNCTION, because `run(map.Rule, …)` is handed the rule, not the
     // map, and would otherwise have nothing to check against. Done once at fuse time,
     // before any rule has been called, so it costs nothing per parse.
@@ -10974,7 +11156,8 @@ function materializePiece(p, trivia2, captureTerminals = false, hostMode) {
   const pieces = compileLinkable(evalRuleMapIR(p.ir), p.ns, {
     ...trivia2 ? { trivia: trivia2 } : {},
     ...captureTerminals ? { captureTerminals: true } : {},
-    ...hostMode ? { hostMode } : {}
+    ...hostMode ? { hostMode } : {},
+    ...p.trackLines ? { trackLines: true } : {}
   });
   if (!pieces) throw new Error(`compose: carried IR for ns "${p.ns}" could not be re-lowered`);
   return pieces;
@@ -11158,19 +11341,19 @@ function directBuilderUnsupportedBindings(src) {
 // src/plugin/evaluator.ts
 function stripTsFromSource(node2, code) {
   const cuts = [];
-  const walk2 = (n) => {
+  const walk = (n) => {
     if (!n || typeof n !== "object") return;
     const rec = n;
     if (typeof rec.type === "string" && rec.type.startsWith("TS") && typeof rec.start === "number" && typeof rec.end === "number") {
       const ex = rec.expression;
       if ((rec.type === "TSAsExpression" || rec.type === "TSSatisfiesExpression" || rec.type === "TSNonNullExpression" || rec.type === "TSInstantiationExpression") && ex && typeof ex.end === "number") {
         cuts.push([ex.end, rec.end]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       if (rec.type === "TSTypeAssertion" && ex && typeof ex.start === "number") {
         cuts.push([rec.start, ex.start]);
-        walk2(rec.expression);
+        walk(rec.expression);
         return;
       }
       cuts.push([rec.start, rec.end]);
@@ -11180,11 +11363,11 @@ function stripTsFromSource(node2, code) {
       if (key === "type" || key === "start" || key === "end") continue;
       const v2 = rec[key];
       if (Array.isArray(v2)) {
-        for (const item of v2) walk2(item);
-      } else if (v2 && typeof v2 === "object") walk2(v2);
+        for (const item of v2) walk(item);
+      } else if (v2 && typeof v2 === "object") walk(v2);
     }
   };
-  walk2(node2);
+  walk(node2);
   const start = node2.start;
   const end = node2.end;
   if (cuts.length === 0) return code.slice(start, end);
@@ -11363,10 +11546,38 @@ function scopeGet(scope, name, mfs) {
   if (isCombinator(entry)) return entry;
   return null;
 }
+function unwrapStaticExpr(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
 function staticLiteralValue(expr) {
-  const val = expr;
+  const val = unwrapStaticExpr(expr);
   return val.type === "Literal" || val.type === "BooleanLiteral" || val.type === "NumericLiteral" ? val.value : void 0;
 }
+function staticStringArray(expr, scope) {
+  const id = unwrapStaticExpr(expr);
+  if (id.type === "Identifier" && scope !== void 0 && id.name !== void 0) {
+    const scoped = scope.get(id.name);
+    const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+    return Array.isArray(value) && value.every((v2) => typeof v2 === "string") ? value : void 0;
+  }
+  const arr = id;
+  if (arr.type !== "ArrayExpression" || !Array.isArray(arr.elements)) return void 0;
+  const out = [];
+  for (const el of arr.elements) {
+    if (!el || el.type === "SpreadElement") return void 0;
+    const value = staticLiteralValue(el);
+    if (typeof value !== "string") return void 0;
+    out.push(value);
+  }
+  return out;
+}
+var STATIC_NODE_OPTIONS_FAILED = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.failed");
+var STATIC_NODE_OPTIONS_NOT_OPTIONS = /* @__PURE__ */ Symbol("parseman.staticNodeOptions.notOptions");
 function staticNodeProject(expr) {
   const literalValue = staticLiteralValue(expr);
   if (typeof literalValue === "number" && Number.isInteger(literalValue) && literalValue >= 0) {
@@ -11375,23 +11586,60 @@ function staticNodeProject(expr) {
   if (typeof literalValue === "number" || literalValue !== void 0) return { ok: false };
   return { ok: false };
 }
-function staticNodeOptions(expr) {
-  if (expr.type !== "ObjectExpression") return void 0;
+function scopedStaticValue(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  if (unwrapped.type !== "Identifier" || unwrapped.name === "undefined") return { found: false };
+  if (!scope.has(unwrapped.name)) return { found: false };
+  const scoped = scope.get(unwrapped.name);
+  const value = isStaticValueEntry(scoped) ? scoped.value : scoped;
+  return { found: true, value };
+}
+function staticNodeOptionsFromValue(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || isCombinator(value)) return STATIC_NODE_OPTIONS_NOT_OPTIONS;
+  const opts = {};
+  const rec = value;
+  for (const name of Object.keys(rec)) {
+    const v2 = rec[name];
+    if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
+      if (v2 === true) opts[name] = true;
+      else if (v2 !== false && v2 !== void 0) return STATIC_NODE_OPTIONS_FAILED;
+    } else if (name === "project") {
+      if (typeof v2 !== "number" || !Number.isInteger(v2) || v2 < 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.project = v2;
+    } else if (name === "tags") {
+      if (!Array.isArray(v2) || !v2.every((item) => typeof item === "string")) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = v2;
+    }
+  }
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
+}
+function staticNodeOptions(expr, scope) {
+  const unwrapped = unwrapStaticExpr(expr);
+  const scoped = scopedStaticValue(unwrapped, scope);
+  if (scoped.found) return staticNodeOptionsFromValue(scoped.value);
+  if (unwrapped.type !== "ObjectExpression") return STATIC_NODE_OPTIONS_NOT_OPTIONS;
   const opts = {};
-  for (const prop of expr.properties) {
+  for (const prop of unwrapped.properties) {
+    if (prop.type !== "Property") return STATIC_NODE_OPTIONS_FAILED;
     const p = prop;
-    if (p.computed) continue;
+    if (p.computed) return STATIC_NODE_OPTIONS_FAILED;
     const key = p.key;
     const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
     if (name === "unwrap" || name === "collapse" || name === "captureTrivia" || name === "trailingTrivia") {
-      if (staticLiteralValue(p.value) === true) opts[name] = true;
+      const value = staticLiteralValue(p.value);
+      if (value === true) opts[name] = true;
+      else if (value !== false && value !== void 0) return STATIC_NODE_OPTIONS_FAILED;
     } else if (name === "project") {
       const project = staticNodeProject(p.value);
-      if (project?.ok === false) return { project: -1 };
+      if (project?.ok === false) return STATIC_NODE_OPTIONS_FAILED;
       if (project !== void 0) opts.project = project.value;
+    } else if (name === "tags") {
+      const tags = staticStringArray(p.value, scope);
+      if (tags === void 0) return STATIC_NODE_OPTIONS_FAILED;
+      opts.tags = tags;
     }
   }
-  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia ? opts : void 0;
+  return opts.unwrap || opts.collapse || opts.project !== void 0 || opts.captureTrivia || opts.trailingTrivia || opts.tags !== void 0 ? opts : void 0;
 }
 function exprToCombi(node2, scope, code, mfs) {
   if (node2.type === "Identifier") return scopeGet(scope, node2.name, mfs);
@@ -11466,10 +11714,23 @@ function exprToCombi(node2, scope, code, mfs) {
     const inner = anyValue(parserArg, scope, code, mfs);
     if (!isCombinator(inner)) return null;
     const be = buildArg;
-    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && be.type !== "ObjectExpression" && !(be.type === "Identifier" && be.name === "undefined");
+    const buildExpr = be === void 0 || be.type === "SpreadElement" ? void 0 : unwrapStaticExpr(be);
+    const buildArgOptions = be !== void 0 && be.type !== "SpreadElement" ? staticNodeOptions(buildArg, scope) : STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    if (buildArgOptions === STATIC_NODE_OPTIONS_FAILED) return null;
+    const buildArgIsOptions = buildArgOptions !== STATIC_NODE_OPTIONS_NOT_OPTIONS;
+    const scopedBuild = buildExpr === void 0 ? { found: false } : scopedStaticValue(buildExpr, scope);
+    const absentBuild = buildExpr?.type === "Identifier" && buildExpr.name === "undefined" || buildExpr !== void 0 && staticLiteralValue(buildExpr) === null || scopedBuild.found && (scopedBuild.value === void 0 || scopedBuild.value === null);
+    const hasBuild = be !== void 0 && be.type !== "SpreadElement" && !buildArgIsOptions && !absentBuild;
     const buildSrc = hasBuild ? stripTsFromSource(be, code) : void 0;
-    const optionsArg = hasBuild ? optsArg : be?.type === "ObjectExpression" ? buildArg : optsArg;
-    const opts = optionsArg !== void 0 && optionsArg.type !== "SpreadElement" ? staticNodeOptions(optionsArg) : void 0;
+    let opts;
+    if (buildArgIsOptions) {
+      opts = buildArgOptions;
+    } else if (optsArg !== void 0) {
+      if (optsArg.type === "SpreadElement") return null;
+      const optsResult = staticNodeOptions(optsArg, scope);
+      if (optsResult === STATIC_NODE_OPTIONS_FAILED || optsResult === STATIC_NODE_OPTIONS_NOT_OPTIONS) return null;
+      opts = optsResult;
+    }
     try {
       const combi = explicitType !== void 0 ? node(explicitType, inner, hasBuild ? () => null : void 0, opts) : node(inner, hasBuild ? () => null : void 0, opts);
       if (combi._def.tag === "node" && buildSrc !== void 0) {
@@ -11692,6 +11953,10 @@ function exprToCombi(node2, scope, code, mfs) {
   }
 }
 function anyValue(node2, scope, code, mfs) {
+  if (node2.type === "TSAsExpression" || node2.type === "TSSatisfiesExpression" || node2.type === "TSNonNullExpression" || node2.type === "TSTypeAssertion" || node2.type === "TSInstantiationExpression" || node2.type === "ParenthesizedExpression") {
+    const inner = node2.expression;
+    return inner ? anyValue(inner, scope, code, mfs) : null;
+  }
   if (node2.type === "Literal") {
     if ("regex" in node2 && node2.regex !== null && node2.regex !== void 0) {
       return new RegExp(node2.regex.pattern, node2.regex.flags);
@@ -11815,6 +12080,9 @@ function collectRuleKeys(retObj) {
   }
   return out;
 }
+function evaluateStaticValue(node2, scope, code) {
+  return anyValue(node2, scope, code, []);
+}
 function flattenRuleEntries(retObj, scope, code) {
   const out = [];
   for (const prop of retObj.properties) {
@@ -11980,6 +12248,18 @@ function referencesAny(node2, names, scope) {
 // src/plugin/index.ts
 import { createHash } from "node:crypto";
 var PARSEMAN_MODULE = "parseman";
+function unwrapStaticExpression(expr) {
+  let cur = expr;
+  while (cur.type === "TSAsExpression" || cur.type === "TSSatisfiesExpression" || cur.type === "TSNonNullExpression" || cur.type === "TSTypeAssertion" || cur.type === "TSInstantiationExpression" || cur.type === "ParenthesizedExpression") {
+    if (!cur.expression) break;
+    cur = cur.expression;
+  }
+  return cur;
+}
+function isStaticNullishExpression(expr) {
+  const unwrapped = unwrapStaticExpression(expr);
+  return unwrapped.type === "Identifier" && unwrapped.name === "undefined" || unwrapped.type === "Literal" && unwrapped.value === null;
+}
 var _compiledResolver = null;
 function getCompiledResolver() {
   return _compiledResolver ??= new ResolverFactory({
@@ -12221,6 +12501,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const macroImports = [];
   const allNames = /* @__PURE__ */ new Set();
   const importBindings = /* @__PURE__ */ new Map();
+  const ordinaryImports = [];
   for (const stmt of body) {
     if (stmt.type !== "ImportDeclaration") continue;
     const s = stmt;
@@ -12229,12 +12510,17 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       return key === "type" && a.value.value === "macro";
     });
     if (!isMacro) {
+      const specifiers = [];
       for (const spec of s.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const imported = spec.imported.name ?? spec.local.name;
           importBindings.set(spec.local.name, { source: s.source.value, imported });
+          specifiers.push({ type: spec.type, local: spec.local.name, start: spec.start, end: spec.end });
+        } else {
+          specifiers.push({ type: spec.type, local: spec.local.name, start: spec.start, end: spec.end });
         }
       }
+      ordinaryImports.push({ start: s.start, end: s.end, specifiers });
       continue;
     }
     const names = /* @__PURE__ */ new Set();
@@ -12245,6 +12531,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     for (const n of names) allNames.add(n);
   }
   if (macroImports.length === 0) return null;
+  const unwrapVd = (stmt) => stmt.type === "VariableDeclaration" ? stmt : stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration" ? stmt.declaration : null;
   const factoryDecls = /* @__PURE__ */ new Map();
   for (const stmt of body) {
     const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
@@ -12262,6 +12549,101 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       }
     }
   }
+  const topLevelFunction = (moduleBody, name) => {
+    for (const st of moduleBody) {
+      const decl = st.type === "ExportNamedDeclaration" ? st.declaration : st;
+      const idn = decl?.type === "FunctionDeclaration" ? decl.id : void 0;
+      if (idn?.name === name) return decl ?? null;
+    }
+    return null;
+  };
+  const isParsemanMacroImport = (stmt) => {
+    if (stmt.type !== "ImportDeclaration") return false;
+    const s = stmt;
+    return moduleAliases.has(s.source.value) && s.attributes.some((a) => {
+      const key = a.key.type === "Identifier" ? a.key.name : String(a.key.value);
+      return key === "type" && a.value.value === "macro";
+    });
+  };
+  const sourceScopeUntil = (moduleBody, source, until) => {
+    const out = /* @__PURE__ */ new Map();
+    for (const stmt of moduleBody) {
+      if (stmt.type === "ImportDeclaration") {
+        if (!isParsemanMacroImport(stmt)) return null;
+        continue;
+      }
+      if (stmt.type === "FunctionDeclaration") continue;
+      if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "FunctionDeclaration") continue;
+      if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration) {
+        if (stmt.source) return null;
+        continue;
+      }
+      const vd = unwrapVd(stmt);
+      if (!vd || vd.kind !== "const") return null;
+      for (const decl of vd.declarations) {
+        const d = decl;
+        const idn = d.id;
+        const init = d.init;
+        if (idn.type !== "Identifier" && idn.type !== "BindingIdentifier" || !idn.name || !init) return null;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") continue;
+        const mapFnSources = [];
+        const combi = evaluateExpr(init, out, source, mapFnSources);
+        if (combi) {
+          if (stmt.start < until) out.set(idn.name, { combi, mfSrcs: mapFnSources });
+          continue;
+        }
+        const wordFactory = evaluateWordFactory(init, out, source);
+        if (wordFactory) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, wordFactory);
+          }
+          continue;
+        }
+        const whenFactory = evaluateWhenFactory(init, out, source);
+        if (whenFactory) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, whenFactory);
+          }
+          continue;
+        }
+        const combiArray = evaluateCombinatorArray(init, out, source);
+        if (combiArray) {
+          if (stmt.start < until) {
+            ;
+            out.set(idn.name, combiArray);
+          }
+          continue;
+        }
+        return null;
+      }
+      continue;
+    }
+    return out;
+  };
+  const usedImportedFactories = /* @__PURE__ */ new Set();
+  const markUsedImportedFactories = (names) => {
+    for (const name of names ?? []) usedImportedFactories.add(name);
+  };
+  for (const [localName, binding] of importBindings) {
+    const file = resolvePrivateSourceModule(id, binding.source);
+    if (!file) continue;
+    const mod = parseModuleCached(file);
+    if (!mod) continue;
+    const localFor = exportLocalName(mod.body, binding.imported);
+    const init = localFor ? topLevelInit(mod.body, localFor) ?? topLevelFunction(mod.body, localFor) : null;
+    if (!init || init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression" && init.type !== "FunctionDeclaration") continue;
+    const factoryScope = sourceScopeUntil(mod.body, mod.src, init.start);
+    if (!factoryScope) continue;
+    factoryDecls.set(localName, {
+      fn: init,
+      declaredAt: -1,
+      code: mod.src,
+      scope: factoryScope,
+      imported: true
+    });
+  }
   const scope = /* @__PURE__ */ new Map();
   const replacements = [];
   const warnings = [];
@@ -12291,6 +12673,9 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     const namedFactory = factoryArgRaw.type === "Identifier" ? factoryDecls.get(factoryArgRaw.name) : void 0;
     const factoryArg = namedFactory !== void 0 && namedFactory.declaredAt <= init.start ? namedFactory.fn : factoryArgRaw;
+    const factoryScope = namedFactory?.scope ?? scope;
+    const factoryCode = namedFactory?.code ?? code;
+    const importedFactory = namedFactory?.imported === true && factoryArg === namedFactory.fn ? factoryArgRaw.name : void 0;
     const optionsArg = optionsFirst ? arg0 : arg1;
     const optionValue = (name) => optionsArg?.type === "ObjectExpression" ? (optionsArg.properties ?? []).find(
       (p) => p.key?.name === name
@@ -12301,7 +12686,13 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       warn(init.start, `${label2}: rules({ hostMode }) must be the literal 'ast' or 'cst'`);
       return null;
     }
-    const ruleMap = evaluateParserFactory(factoryArg, scope, code, []);
+    const trackLinesValue = optionValue("trackLines");
+    const gTrackLines = trackLinesValue?.type === "Literal" ? trackLinesValue.value : void 0;
+    if (trackLinesValue !== void 0 && typeof gTrackLines !== "boolean") {
+      warn(init.start, `${label2}: rules({ trackLines }) must be a boolean literal`);
+      return null;
+    }
+    const ruleMap = evaluateParserFactory(factoryArg, factoryScope, factoryCode, []);
     if (!ruleMap) {
       warn(init.start, `${label2}: rules(...) factory isn't statically evaluable`);
       return null;
@@ -12326,20 +12717,37 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         }
       }
     }
-    return { ruleMap, ...gTrivia ? { trivia: gTrivia } : {}, ...gScanSkip ? { scanSkip: gScanSkip } : {} };
+    if (gTrackLines === true) {
+      for (const rule of ruleMap.values()) {
+        if (rule && !rule._meta.isTrivia) {
+          ;
+          rule._meta.grammarTrackLines = true;
+        }
+      }
+    }
+    return {
+      ruleMap,
+      ...gTrivia ? { trivia: gTrivia } : {},
+      ...gScanSkip ? { scanSkip: gScanSkip } : {},
+      ...gTrackLines === true ? { trackLines: true } : {},
+      ...importedFactory ? { importedFactory } : {}
+    };
   };
   const compileRulesFactory = (init, label2) => {
     const evaluated = evaluateRulesFactory(init, label2);
     if (!evaluated) return null;
-    const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, recovery, coverage: grammarCoverage });
+    const compiled = compileRuleMap([...evaluated.ruleMap], { ...evaluated.trivia ? { trivia: evaluated.trivia } : {}, ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}, ...evaluated.trackLines ? { trackLines: true } : {}, recovery, coverage: grammarCoverage });
     return {
       replacement: compiled?.replacement ?? null,
       ruleMap: evaluated.ruleMap,
       hostMode: compiled?.hostMode ?? "ast",
       hostBranchElided: compiled?.hostBranchElided ?? false,
+      reflection: compiled?.reflection ?? { nodes: [] },
       ...compiled?.coverageDefinitions ? { coverageDefinitions: compiled.coverageDefinitions } : {},
       ...evaluated.trivia ? { trivia: evaluated.trivia } : {},
-      ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {}
+      ...evaluated.scanSkip ? { scanSkip: evaluated.scanSkip } : {},
+      ...evaluated.trackLines ? { trackLines: true } : {},
+      ...evaluated.importedFactory ? { importedFactory: evaluated.importedFactory } : {}
     };
   };
   const isRulesCall = (init) => init.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "rules";
@@ -12355,15 +12763,16 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     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 `{ v: ${JSON.stringify(p.v)}, 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)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
+    return `{ v: ${JSON.stringify(p.v)}, 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)}, nullable: ${p.nullable ? mapLit(p.nullable) : "new Map()"}, firstSetRecipes: ${p.firstSetRecipes ? mapLit(p.firstSetRecipes) : "new Map()"}, deps: ${mapLit(p.deps)}, nodeMeta: ${mapLit(p.nodeMeta)}, hostMode: ${JSON.stringify(p.hostMode ?? "ast")}, hostBranchElided: ${p.hostBranchElided === true}, needsEmptyTl: ${p.needsEmptyTl}, needsHostReads: ${p.needsHostReads}, hasDirectBuilders: ${p.hasDirectBuilders === true}, isRecognitionOnly: ${p.isRecognitionOnly === true}, mfFns: [], buildFns: [] }`;
   };
   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 serializeItem = (it) => isSpread(it) ? `...(${it.__spreadLocal}[Symbol.for('parseman.composedPieces')] ?? [])` : isIR(it) ? `{ ns: ${JSON.stringify(it.ns)}, ir: ${JSON.stringify(it.ir)}${it.trackLines ? ", trackLines: true" : ""} }` : 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 withLeafMarker = (grammarExpr) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.leafComposed'), { value: true, enumerable: false })`;
   const withHostMode = (grammarExpr, mode, elided) => `/* @__PURE__ */ (m => { for (const k of Object.keys(m)) { Object.defineProperty(m[k], Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m[k], Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }) } Object.defineProperty(m, Symbol.for('parseman.fusedHostMode'), { value: ${JSON.stringify(mode)}, enumerable: false }); Object.defineProperty(m, Symbol.for('parseman.fusedHostElided'), { value: ${JSON.stringify(elided)}, enumerable: false }); return m })(${grammarExpr})`;
+  const withGrammarReflection = (grammarExpr, reflection) => `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarReflection'), { value: ${grammarReflectionSource(reflection)}, enumerable: false })`;
   const withCoverageDefinitions = (grammarExpr, definitions) => !grammarCoverage ? grammarExpr : `/* @__PURE__ */ Object.defineProperty(${grammarExpr}, Symbol.for('parseman.grammarCoverageDefinitions'), { value: Object.freeze(${JSON.stringify(definitions)}.map(Object.freeze)), enumerable: false })`;
   const emittedCoverageDefinitions = (source) => {
     const ids = /* @__PURE__ */ new Set();
@@ -12490,10 +12899,11 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   const localCarried = (rm, label2, composing, scanSkip) => {
     const entries = [...rm];
     const ns = nsFor(label2);
+    const trackLines = entries.some(([, rule]) => rule?._meta?.grammarTrackLines === true);
     const ir = serializeRuleMap(entries, scanSkip);
-    if (ir) return { carried: [{ ns, ir }] };
+    if (ir) return { carried: [{ ns, ir, ...trackLines ? { trackLines: true } : {} }] };
     warn(0, `${label2}: rule map could not be serialized to IR; carrying FULL pieces instead. The artifact is correct but larger, and a downstream compose cannot re-lower it. Re-run with PARSEMAN_IR_DEBUG=1 to print the exact combinator that blocked serialization.`);
-    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, recovery });
+    const p = compileLinkable(entries, ns, { ...composing ? { trivia: composing } : {}, ...scanSkip ? { scanSkip } : {}, ...trackLines ? { trackLines: true } : {}, recovery });
     return p ? { carried: [p] } : null;
   };
   const argPieces = (arg, label2, composing) => {
@@ -12511,7 +12921,10 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const innerArg = argPieces(inner, `${label2}_pick`);
       if (!innerArg) return null;
       try {
-        return { carried: pickPieces(materializeCarried(innerArg.carried, ownTrivia(inner)), names) };
+        return {
+          carried: pickPieces(materializeCarried(innerArg.carried, ownTrivia(inner)), names),
+          ...innerArg.importedFactories ? { importedFactories: innerArg.importedFactories } : {}
+        };
       } catch (e) {
         warn(arg.start, `pick(): ${e.message}`);
         return null;
@@ -12519,7 +12932,8 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     if (isRulesCall(arg)) {
       const evaluated = evaluateRulesFactory(arg, label2);
-      return evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
+      const carried = evaluated ? localCarried(evaluated.ruleMap, label2, composing, evaluated.scanSkip) : null;
+      return carried ? { ...carried, ...evaluated?.importedFactory ? { importedFactories: [evaluated.importedFactory] } : {} } : null;
     }
     if (arg.type === "Identifier") {
       const name = arg.name;
@@ -12591,6 +13005,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     }
     const composing = composingTrivia(elements);
     const carried = [];
+    const importedFactories = [];
     for (let i = 0; i < elements.length; i++) {
       const r = argPieces(elements[i], `compose${init.start}_${i}`, composing);
       if (!r) {
@@ -12598,6 +13013,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       carried.push(...r.carried);
+      importedFactories.push(...r.importedFactories ?? []);
     }
     const detailed = once(() => carriedRuleMapsDetailed(carried));
     runFusedGatingDiagnostic(
@@ -12607,7 +13023,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     );
     const pieces = materializeCarried(carried, composing, false, cHostMode);
     try {
-      return { replacement: emitFusedSource(pieces), carried, ...composing ? { trivia: composing } : {} };
+      return {
+        replacement: emitFusedSource(pieces),
+        carried,
+        ...composing ? { trivia: composing } : {},
+        ...importedFactories.length ? { importedFactories } : {}
+      };
     } catch (e) {
       warn(init.start, `compose(): ${e.message}; falling back to runtime`);
       return null;
@@ -12628,10 +13049,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     const localArg = elements[elements.length - 1];
     let localRules = null;
     let localScanSkip;
+    const importedFactories = [];
     if (isRulesCall(localArg)) {
       const evaluated = evaluateRulesFactory(localArg, `composeLeaf${init.start}`);
       localRules = evaluated?.ruleMap ?? null;
       localScanSkip = evaluated?.scanSkip;
+      if (evaluated?.importedFactory) importedFactories.push(evaluated.importedFactory);
     } else if (localArg.type === "Identifier") {
       const name = localArg.name;
       localRules = localRuleMaps.get(name) ?? null;
@@ -12650,6 +13073,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       carried.push(...r.carried);
+      importedFactories.push(...r.importedFactories ?? []);
     }
     try {
       const localNs = nsFor(`composeLeaf${init.start}`);
@@ -12675,13 +13099,15 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
         return null;
       }
       const replacement = withLeafMarker(emitFusedSource(grammarCoverage ? recognitionPieces : [...recognitionPieces, plainLocalPiece]));
-      return { replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) };
+      return {
+        replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)),
+        ...importedFactories.length ? { importedFactories } : {}
+      };
     } catch (e) {
       warn(init.start, `composeLeaf(): ${e.message}`);
       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) {
     const innerVd = unwrapVd(stmt);
@@ -12742,7 +13168,14 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       const kind = vd.kind ?? "const";
       if (d.id.type === "Identifier") {
         const varName = d.id.name;
-        if (!referencesAny(init, allNames, scope)) continue;
+        if (!referencesAny(init, allNames, scope)) {
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+          }
+          continue;
+        }
         if (refNames.has(varName)) {
           const refEntry = scope.get(varName);
           const refCombi = refEntry?.combi ?? null;
@@ -12765,6 +13198,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           const ns = nsFor(varName);
           const pieces = exportPrefix || compiledRules.replacement === null ? compileLinkable([...compiledRules.ruleMap], ns, {
             ...compiledRules.scanSkip ? { scanSkip: compiledRules.scanSkip } : {},
+            ...compiledRules.trackLines ? { trackLines: true } : {},
             recovery
           }) : null;
           if (compiledRules.replacement === null) {
@@ -12781,12 +13215,16 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           );
           if (compiledRules.replacement !== null) {
             replacement = withHostMode(replacement, compiledRules.hostMode, compiledRules.hostBranchElided);
+            replacement = withGrammarReflection(replacement, compiledRules.reflection);
           }
           if (exportPrefix && pieces && !pieces.mfFns.length && !pieces.buildFns.length) {
             const ir = serializeRuleMap([...compiledRules.ruleMap], compiledRules.scanSkip);
-            replacement = withCarriedPieces(replacement, [ir ? { ns, ir } : pieces]);
+            replacement = withCarriedPieces(replacement, [ir ? { ns, ir, ...compiledRules.trackLines ? { trackLines: true } : {} } : pieces]);
           }
           replacements.push({ start: init.start, end: init.end, replacement });
+          if (compiledRules.replacement !== null) {
+            markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
+          }
           continue;
         }
         if (isComposeCall(init)) {
@@ -12799,6 +13237,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           if (fused.trivia) localComposedTrivia.set(varName, fused.trivia);
           const replacement = exportPrefix ? withCarriedPieces(fused.replacement, fused.carried) : fused.replacement;
           replacements.push({ start: init.start, end: init.end, replacement: withCoverageDefinitions(replacement, emittedCoverageDefinitions(replacement)) });
+          markUsedImportedFactories(fused.importedFactories);
           continue;
         }
         if (isComposeLeafCall(init)) {
@@ -12807,6 +13246,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             throw new Error(`${id}:${lineOf(init.start)} \u2014 composeLeaf() must macro-fuse; runtime composition is forbidden`);
           }
           replacements.push({ start: init.start, end: init.end, replacement: fused.replacement });
+          markUsedImportedFactories(fused.importedFactories);
           continue;
         }
         const mapFnSources = [];
@@ -12832,6 +13272,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
             scope.set(varName, combiArray);
             continue;
           }
+          const staticValue = evaluateStaticValue(init, scope, code);
+          if (staticValue !== null && staticValue !== void 0 || isStaticNullishExpression(init)) {
+            ;
+            scope.set(varName, staticValue);
+            continue;
+          }
           if (factoryDecls.has(varName)) continue;
           warn(init.start, `"${varName}" references a parseman macro import but isn't a statically-evaluable combinator`);
           continue;
@@ -12895,6 +13341,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           end: stmtEnd,
           replacement: lines.join("\n")
         });
+        markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
       }
     }
   }
@@ -12903,6 +13350,40 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     imp.fullyResolved = !anyUnresolved && !keepMacroImport;
   }
   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);
+  const importedBindingStillReferenced = (local) => {
+    const walk = (node2, parent, parentKey) => {
+      if (!node2 || typeof node2 !== "object") return false;
+      const rec = node2;
+      if (rec.type === "ImportDeclaration") return false;
+      if (typeof rec.start === "number" && typeof rec.end === "number" && isInsideReplacement(rec.start, rec.end)) return false;
+      if ((rec.type === "Identifier" || rec.type === "BindingIdentifier") && rec.name === local) {
+        if (parentKey === "key" && (parent?.type === "ObjectProperty" || parent?.type === "Property" || parent?.type === "PropertyDefinition") && parent.computed !== true) return false;
+        if (parentKey === "property" && parent?.type === "StaticMemberExpression") return false;
+        if (parentKey === "property" && parent?.type === "MemberExpression" && parent.computed !== true) return false;
+        return true;
+      }
+      for (const key of Object.keys(rec)) {
+        if (key === "type" || key === "start" || key === "end") continue;
+        const value = rec[key];
+        if (Array.isArray(value)) {
+          if (value.some((child) => walk(child, rec, key))) return true;
+        } else if (walk(value, rec, key)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    return body.some((stmt) => walk(stmt));
+  };
+  for (const imp of ordinaryImports) {
+    if (!runtimeComposeFallback && imp.specifiers.length > 0 && imp.specifiers.every(
+      (spec) => spec.type === "ImportSpecifier" && usedImportedFactories.has(spec.local) && !importedBindingStillReferenced(spec.local)
+    )) {
+      ms.remove(imp.start, imp.end);
+    }
+  }
   if (!anyUnresolved) {
     for (const { start, end } of defineRemovals) ms.remove(start, end);
   }