parseman 0.42.0 → 0.42.1

package/dist/plugin/index.cjs

@@ -2777,6 +2777,74 @@ 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/combinators/parser.ts
 var RULE_ORDER = "__parsemanRuleOrder";
 function tagRule(r, key) {
@@ -2852,6 +2920,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]);
   }
@@ -3308,74 +3391,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 = {
@@ -3472,7 +3487,7 @@ function leaf(root, fn) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.42.0";
+var PARSEMAN_VERSION = "0.42.1";
 
 // src/cst/host-mode.ts
 var FUSED_HOST_MODE = /* @__PURE__ */ Symbol.for("parseman.fusedHostMode");
@@ -6840,13 +6855,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) {
@@ -6871,7 +6889,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);
@@ -6881,18 +6899,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") {
@@ -6900,10 +6919,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 [
@@ -8336,7 +8355,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}`
@@ -8835,7 +8854,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}`
@@ -9351,6 +9370,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 {
@@ -9708,6 +9728,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,
@@ -9728,7 +9749,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 } : {},
@@ -9892,6 +9913,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,
@@ -9912,6 +9934,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 } : {},
@@ -9945,6 +9968,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() : [];
@@ -9974,15 +10001,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`
@@ -10020,6 +10055,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;
@@ -10054,6 +10090,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,
@@ -10150,6 +10187,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();
@@ -10163,6 +10204,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,
@@ -10171,11 +10214,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));
   }
@@ -11009,7 +11059,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;
@@ -12256,6 +12307,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;
@@ -12264,12 +12316,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();
@@ -12280,6 +12337,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;
@@ -12297,6 +12355,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 = [];
@@ -12326,6 +12479,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
@@ -12336,7 +12492,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;
@@ -12361,12 +12523,26 @@ 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,
@@ -12374,7 +12550,9 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
       hostBranchElided: compiled?.hostBranchElided ?? false,
       ...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";
@@ -12394,7 +12572,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
   };
   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 })`;
@@ -12525,10 +12703,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) => {
@@ -12546,7 +12725,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;
@@ -12554,7 +12736,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;
@@ -12626,6 +12809,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) {
@@ -12633,6 +12817,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(
@@ -12642,7 +12827,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;
@@ -12663,10 +12853,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;
@@ -12685,6 +12877,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}`);
@@ -12710,13 +12903,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);
@@ -12800,6 +12995,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) {
@@ -12819,9 +13015,12 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           }
           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)) {
@@ -12834,6 +13033,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)) {
@@ -12842,6 +13042,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 = [];
@@ -12930,6 +13131,7 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
           end: stmtEnd,
           replacement: lines.join("\n")
         });
+        markUsedImportedFactories(compiledRules.importedFactory ? [compiledRules.importedFactory] : void 0);
       }
     }
   }
@@ -12938,6 +13140,40 @@ function transformMacro(code, id, moduleAliases = /* @__PURE__ */ new Set([PARSE
     imp.fullyResolved = !anyUnresolved && !keepMacroImport;
   }
   const ms = new import_magic_string.default(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 walk2 = (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) => walk2(child, rec, key))) return true;
+        } else if (walk2(value, rec, key)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    return body.some((stmt) => walk2(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);
   }