parseman 0.50.4 → 0.50.6

package/dist/index.js

@@ -16986,6 +16986,32 @@ var Serializer = class {
   body(c) {
     return c._def.tag === "lazy" && ruleNameOf4(c) !== void 0 ? lazyTarget(c) ?? c : c;
   }
+  /**
+   * The child a rule-entry grammar scope should serialize as its body, when that
+   * scope merely WRAPS the rule's own named `lazy` proxy.
+   *
+   * `rules({ trackLines: true }, …)` wraps every rule VALUE — which is that rule's
+   * own named lazy proxy — in a `grammarParser({ trackLines: true })` scope
+   * (`parser.ts:229-242`). `body()` unwraps a BARE lazy entry to its defined target;
+   * a lazy wrapped one level deep by that scope must be unwrapped INSIDE the scope
+   * too. Left wrapped, the inner proxy serializes as a `g[name]` SELF-reference and
+   * the rule's real body is dropped, so it re-lowers to `Name: parser(opts, g.Name)`
+   * — a bodyless self-cycle the table encoder rejects with `alias cycle — lazy (rule
+   * 'Name') encodes to its own recursion trampoline`. This is why the four
+   * `*PositionsGrammar` exports fell back to a runtime `compose()` under trackLines.
+   *
+   * STRICT: only a scope that IS a rule entry (in `localRuleNames`) AND wraps ITS
+   * OWN name unwraps. A scope wrapping another rule's ref (a genuine cross-rule
+   * alias, `Name: parser(opts, g.Other)`) or a real body is untouched, so the
+   * non-trackLines and non-self-wrap output stays byte-identical.
+   */
+  scopeSelfBody(c) {
+    const name = this.localRuleNames.get(c);
+    if (name === void 0 || c._def.tag !== "grammar") return void 0;
+    const inner = c._def.parser;
+    if (inner._def.tag !== "lazy" || ruleNameOf4(inner) !== name) return void 0;
+    return lazyTarget(inner) ?? void 0;
+  }
   run() {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), /* @__PURE__ */ new Set());
     for (const c of this.scanSkip) {
@@ -17055,7 +17081,9 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
       return;
     }
     active.add(c);
-    for (const child of childrenOf3(def)) this.analyze(child, active);
+    const selfBody = def.tag === "grammar" ? this.scopeSelfBody(c) : void 0;
+    const kids = selfBody === void 0 ? childrenOf3(def) : def.tag === "grammar" && def.triviaParser ? [selfBody, def.triviaParser] : [selfBody];
+    for (const child of kids) this.analyze(child, active);
     active.delete(c);
   }
   /** Reference `c`: a const var if it has one (emitting its decl first), else inline.
@@ -17221,7 +17249,7 @@ ${outerDecls.map((d) => "  " + d).join("\n")}
         const spec = classified && def.triviaParser ? analyzeLabeledTrivia(def.triviaParser) : null;
         if (classified && !spec) throw new Unserializable("classified trivia without labeled arms");
         const trivia2 = def.clearTrivia ? "null" : spec ? `classifiedTrivia({ ${spec.arms.map((arm) => `${JSON.stringify(arm.label)}: ${kid(arm.parser)}`).join(", ")} })` : def.triviaParser ? kid(def.triviaParser) : "undefined";
-        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(def.parser)})`;
+        return `parser({ trivia: ${trivia2}${def.captureTrivia ? ", captureTrivia: true" : ""}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ""}${def.trackLines ? ", trackLines: true" : ""} }, ${kid(this.scopeSelfBody(c) ?? def.parser)})`;
       }
       case "withCtx": {
         if (def.extraSrc === void 0) throw new Unserializable("withCtx without extraSrc");
@@ -17357,7 +17385,7 @@ function compileRuleMap(ruleMap, opts = {}) {
 }
 
 // src/version.ts
-var PARSEMAN_VERSION = "0.50.4";
+var PARSEMAN_VERSION = "0.50.6";
 
 // src/compiler/compile-linkable-table.ts
 function isLocal(rule) {