parseman 0.50.4 → 0.50.6

package/dist/version.d.ts

@@ -13,5 +13,5 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export declare const PARSEMAN_VERSION = "0.50.4";
+export declare const PARSEMAN_VERSION = "0.50.6";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "parseman",
-  "version": "0.50.4",
+  "version": "0.50.6",
   "packageManager": "pnpm@10.15.1",
   "engines": {
     "node": "^20.19.0 || >=22.13.0"

package/src/compiler/ir-serialize.ts

@@ -321,6 +321,33 @@ class Serializer {
     return c._def.tag === 'lazy' && ruleNameOf(c) !== undefined ? (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.
+   */
+  private scopeSelfBody(c: Comb): Comb | undefined {
+    const name = this.localRuleNames.get(c)
+    if (name === undefined || c._def.tag !== 'grammar') return undefined
+    const inner = c._def.parser
+    if (inner._def.tag !== 'lazy' || ruleNameOf(inner) !== name) return undefined
+    return lazyTarget(inner) ?? undefined
+  }
+
   run(): string {
     for (const [, c] of this.ruleMap) this.analyze(this.body(c), new Set())
     for (const c of this.scanSkip) { this.assertNoRuleRef(c, new Set()); this.analyze(c, new Set()) }
@@ -415,7 +442,19 @@ class Serializer {
       return
     }
     active.add(c)
-    for (const child of childrenOf(def)) this.analyze(child, active)
+    // When a rule-entry scope wraps its own named lazy, substitute the lazy's
+    // unwrapped body for `def.parser` — but keep the scope's OTHER children (its
+    // `triviaParser`) in the analysis, exactly as `childrenOf('grammar')` returns
+    // both. Dropping the trivia parser here would leave a recursive/shared trivia
+    // unanalysed, so its const/self-ref hoisting would be missing when `expr` emits
+    // it via `kid(def.triviaParser)`. selfBody is non-undefined only for `'grammar'`.
+    const selfBody = def.tag === 'grammar' ? this.scopeSelfBody(c) : undefined
+    const kids = selfBody === undefined
+      ? childrenOf(def)
+      : def.tag === 'grammar' && def.triviaParser
+        ? [selfBody, def.triviaParser]
+        : [selfBody]
+    for (const child of kids) this.analyze(child, active)
     active.delete(c)
   }
 
@@ -602,7 +641,7 @@ class Serializer {
           : spec
             ? `classifiedTrivia({ ${spec.arms.map(arm => `${JSON.stringify(arm.label)}: ${kid(arm.parser)}`).join(', ')} })`
             : def.triviaParser ? kid(def.triviaParser) : 'undefined'
-        return `parser({ trivia: ${trivia}${def.captureTrivia ? ', captureTrivia: true' : ''}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ''}${def.trackLines ? ', trackLines: true' : ''} }, ${kid(def.parser)})`
+        return `parser({ trivia: ${trivia}${def.captureTrivia ? ', captureTrivia: true' : ''}${def.rootCapture ? `, rootCapture: ${JSON.stringify(def.rootCapture)}` : ''}${def.trackLines ? ', trackLines: true' : ''} }, ${kid(this.scopeSelfBody(c) ?? def.parser)})`
       }
       case 'withCtx': {
         // A `withCtx` round-trips through `_wc`, which rebuilds it AND re-attaches

package/src/plugin/evaluator.ts

@@ -756,6 +756,19 @@ function exprToCombi(node: Expression, scope: XScope, code?: string, mfs?: strin
             if (prov) carriedImports.push({ local: name, source: prov.source, imported: prov.imported })
             else unresolved.push(name)
           }
+        } else if (be!.type === 'Identifier' && typeof be!.name === 'string' && combi._def.buildSrc === be!.name) {
+          // A NAMED reducer that is a BARE IMPORTED identifier — `node(t, parser, mkRel)`
+          // where `mkRel` is `import { mkRel } from './astf'`. The table inlines the
+          // reducer as its NAME (`f:[mkRel]`), and a cross-package compose that re-lowers
+          // this carried piece re-emits that name verbatim into the consuming module —
+          // which does not import it, so the fused artifact throws ReferenceError. Carry
+          // the ONE import the emitted name needs so the downstream re-emit binds it. This
+          // is the reducer NAME's own import (unambiguous — it is THIS module's import),
+          // never the reducer BODY's internal free names (the `buildSigSrc` P1 trap): the
+          // guard `buildSrc === be.name` also excludes a foreign-factory reducer whose
+          // source was rewritten to a self-contained body above.
+          const prov = _builderImports?.(be!.name) ?? null
+          if (prov) carriedImports.push({ local: be!.name, source: prov.source, imported: prov.imported })
         }
         const staticError = [...report.structural, ...unresolved]
         if (staticError.length > 0) combi._def.buildStaticError = staticError

package/src/version.ts

@@ -13,4 +13,4 @@
  * Kept in sync with `package.json` by `test/unit/version-sync.test.ts`, which fails
  * the build if this constant drifts from the published version.
  */
-export const PARSEMAN_VERSION = '0.50.4'
+export const PARSEMAN_VERSION = '0.50.6'