parseman 0.50.5 → 0.50.7

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.5";
+export declare const PARSEMAN_VERSION = "0.50.7";
 //# sourceMappingURL=version.d.ts.map

package/package.json

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

package/src/combinators/first-set.ts

@@ -25,6 +25,7 @@ export type FinalChoiceClassification = {
 export function classifyFinalChoice(
   arms: readonly Combinator<unknown>[],
   resolve?: RefResolver,
+  activeTrivia?: Combinator<unknown> | null,
 ): FinalChoiceClassification {
   const firstSets: FirstSet[] = []
   const nullable: boolean[] = []
@@ -36,7 +37,7 @@ export function classifyFinalChoice(
   for (const arm of arms) {
     const empty = matchesEmpty(arm, new Set(), resolve)
     nullable.push(empty)
-    firstSets.push(empty ? { kind: 'any' } : firstSetOf(arm, new Set(), resolve))
+    firstSets.push(empty ? { kind: 'any' } : firstSetOf(arm, new Set(), resolve, activeTrivia))
     if (empty) exclusive = false
   }
   if (exclusive) {
@@ -109,7 +110,7 @@ export function intersects(a: FirstSet, b: FirstSet): boolean {
 }
 
 export function fromChar(code: number): FirstSet {
-  return { kind: 'ranges', ranges: [{ lo: code, hi: code }] }
+  return fromRange(code, code)
 }
 
 /**
@@ -238,11 +239,10 @@ function matchesEmptyBody(
  * (see `isPositiveLookahead` and `sequenceFirstSet`).
  */
 export function isZeroWidthAssertion(p: Combinator<unknown>): boolean {
-  const tag = (p._def as ParserDef).tag
   // `adjacency` joins `not` for the same reason: `adjacent()`/`notAdjacent()` are
   // zero-width tests of the gap BEHIND the cursor, so they constrain nothing about
   // the first char ahead and must not contribute their `any` to the sequence.
-  return tag === 'not' || tag === 'adjacency'
+  return p._tag === 'not' || p._tag === 'adjacency'
 }
 
 /**
@@ -259,8 +259,10 @@ export function isZeroWidthAssertion(p: Combinator<unknown>): boolean {
  * therefore constrains nothing; `peek()` reports `any()` in that case, which the
  * intersection treats as "no constraint".
  */
-export function isPositiveLookahead(p: Combinator<unknown>): boolean {
-  return (p._def as ParserDef).tag === 'peek'
+function isPositiveLookahead(
+  p: Combinator<unknown>,
+): p is Combinator<unknown> & { _def: Extract<ParserDef, { tag: 'peek' }> } {
+  return p._tag === 'peek'
 }
 
 /** Intersect a lookahead constraint into an accumulator; `any` = no constraint. */
@@ -285,9 +287,7 @@ function narrowBy(acc: FirstSet | null, constraint: FirstSet): FirstSet | null {
  * only succeed — even zero-width — where X matches.
  */
 function applyAssertion(fs: FirstSet, assertion: FirstSet | null): FirstSet {
-  if (assertion === null) return fs
-  if (fs.kind === 'empty') return assertion
-  return narrowBy(fs, assertion) ?? fs
+  return assertion === null ? fs : fs.kind === 'empty' ? assertion : narrowBy(fs, assertion)!
 }
 
 /**
@@ -299,19 +299,36 @@ function applyAssertion(fs: FirstSet, assertion: FirstSet | null): FirstSet {
  * A leading zero-width assertion (`not(…)`) is nullable but contributes NOTHING to
  * the first-set (see `isZeroWidthAssertion`) — its `any` must not poison the union.
  */
-export function sequenceFirstSet(parsers: readonly Combinator<unknown>[]): FirstSet {
-  let fs: FirstSet = empty()
-  let assertion: FirstSet | null = null
-  for (const p of parsers) {
+function sequenceSet(
+  parsers: readonly Combinator<unknown>[],
+  fs: (p: Combinator<unknown>) => FirstSet,
+  empties: (p: Combinator<unknown>) => boolean,
+  trivia?: Combinator<unknown> | null,
+): FirstSet {
+  const afterBoundary = (i: number): FirstSet => {
+    const rest = at(i)
+    return trivia ? union(rest, fs(trivia)) : rest
+  }
+  const at = (i: number): FirstSet => {
+    const p = parsers[i]!
     if (isPositiveLookahead(p)) {
-      // Zero-width but CONSTRAINING: intersect, keep scanning (it consumes nothing).
-      assertion = narrowBy(assertion, p._meta.firstSet)
-      continue
+      const constraint = fs(p)
+      return i + 1 === parsers.length
+        ? constraint
+        : applyAssertion(afterBoundary(i + 1), constraint)
+    }
+    if (isZeroWidthAssertion(p)) {
+      return i + 1 === parsers.length ? empty() : afterBoundary(i + 1)
     }
-    if (!isZeroWidthAssertion(p)) fs = union(fs, p._meta.firstSet)
-    if (!matchesEmpty(p)) return applyAssertion(fs, assertion)
+    const first = fs(p)
+    if (!empties(p) || i + 1 === parsers.length) return first
+    return union(first, afterBoundary(i + 1))
   }
-  return applyAssertion(fs, assertion)
+  return at(0)
+}
+
+export function sequenceFirstSet(parsers: readonly Combinator<unknown>[]): FirstSet {
+  return sequenceSet(parsers, p => p._meta.firstSet, matchesEmpty)
 }
 
 /**
@@ -335,6 +352,7 @@ export function firstSetOf(
   p: Combinator<unknown>,
   seen: Set<Combinator<unknown>> = new Set(),
   resolve?: RefResolver,
+  activeTrivia?: Combinator<unknown> | null,
 ): FirstSet {
   // `seen` is the current recursion path, not a global visited set. A completed
   // shared child must be analysed again for a sibling; only a back-edge on this
@@ -342,7 +360,7 @@ export function firstSetOf(
   if (seen.has(p)) return any()               // cycle → any (safe over-approximation)
   seen.add(p)
   try {
-    return firstSetBody(p, seen, resolve)
+    return firstSetBody(p, seen, resolve, activeTrivia)
   } finally {
     seen.delete(p)
   }
@@ -352,8 +370,9 @@ function firstSetBody(
   p: Combinator<unknown>,
   seen: Set<Combinator<unknown>>,
   resolve: RefResolver | undefined,
+  activeTrivia: Combinator<unknown> | null | undefined,
 ): FirstSet {
-  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen, resolve)
+  const fs = (c: Combinator<unknown>): FirstSet => firstSetOf(c, seen, resolve, activeTrivia)
   const empties = (c: Combinator<unknown>): boolean => matchesEmpty(c, new Set(), resolve)
   const d = p._def as ParserDef
   switch (d.tag) {
@@ -373,19 +392,17 @@ function firstSetBody(
       return out
     }
     case 'sequence': {
-      // Union through the nullable prefix (a leading nullable term lets a later
-      // term's first chars start the sequence) — ref-resolving `sequenceFirstSet`.
-      // A leading zero-width assertion (`not`) contributes nothing (its `any` would
-      // poison the union) but is still nullable, so keep scanning past it. A
-      // positive `peek()` is zero-width AND constraining → intersect.
-      let out: FirstSet = empty()
-      let assertion: FirstSet | null = null
-      for (const term of d.parsers) {
-        if (isPositiveLookahead(term)) { assertion = narrowBy(assertion, fs(term)); continue }
-        if (!isZeroWidthAssertion(term)) out = union(out, fs(term))
-        if (!empties(term)) return applyAssertion(out, assertion)
-      }
-      return applyAssertion(out, assertion)
+      // A zero-width or nullable term leaves the cursor at its current position,
+      // while every later term first skips active trivia. The sequence can
+      // therefore start with that trivia or with the later term. A positive
+      // lookahead still constrains both possibilities at the cursor where it ran:
+      //
+      //   peek ∩ (later ∪ trivia)
+      //
+      // Recurse at every term boundary because a lookahead after another
+      // zero-width term runs after trivia has advanced, not at the sequence's
+      // original cursor.
+      return sequenceSet(d.parsers, fs, empties, activeTrivia)
     }
     case 'peek': {
       // Deep-resolve the body: a `ref()` reads `any()` at CONSTRUCTION, so the
@@ -402,9 +419,14 @@ function firstSetBody(
     case 'token':
     case 'leaf':
     case 'node':
-    case 'grammar':
+    case 'sepBy':
     case 'expect':    return fs(d.parser)
-    case 'sepBy':     return fs(d.parser)   // both min 0 and min 1 start with the item
+    case 'grammar':   return firstSetOf(
+      d.parser,
+      seen,
+      resolve,
+      d.clearTrivia ? null : (d.triviaParser ?? activeTrivia),
+    )
     default:          return p._meta.firstSet  // not / scanTo / guard / withCtx / recover / unknown
   }
 }

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/table/encode.ts

@@ -539,7 +539,9 @@ class Encoder {
   private followClass(parsers: readonly Combinator<unknown>[], i: number): number {
     let fs: FirstSet = { kind: 'empty' }
     const rr = this.refResolver()
-    for (let j = i + 1; j < parsers.length; j++) fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr))
+    for (let j = i + 1; j < parsers.length; j++) {
+      fs = union(fs, firstSetOf(parsers[j]!, new Set(), rr, this.activeTrivia))
+    }
     return this.charClass(fs)
   }
 
@@ -779,7 +781,7 @@ class Encoder {
    */
   private subtree(c: Combinator<unknown>): SubtreeRef {
     const ip = this.node(c).ip
-    const fs = firstSetOf(c, new Set(), this.refResolver())
+    const fs = firstSetOf(c, new Set(), this.refResolver(), this.activeTrivia)
     return [ip, fs.kind === 'empty' ? -2 : this.charClass(fs)]
   }
 
@@ -1168,7 +1170,7 @@ class Encoder {
         // the O(1) table (`exclusive`) or falls to the ordered per-arm path.
         // Arm ORDER is preserved on both, which is what makes this a PEG-safe
         // change rather than a reordering.
-        const finalChoice = classifyFinalChoice(arms, rr)
+        const finalChoice = classifyFinalChoice(arms, rr, this.activeTrivia)
         // attempt() preserves its child's success language, but the broad
         // classifier deliberately treats the transaction as nullable/unknown so
         // it can never by itself authorize exclusive one-arm selection. Recover
@@ -1180,7 +1182,7 @@ class Encoder {
           if (!finalChoice.nullable[i]) return undefined
           const def = arm._def as ParserDef
           if (def.tag !== 'attempt' || matchesEmpty(def.parser, new Set(), rr)) return undefined
-          return firstSetOf(def.parser, new Set(), rr)
+          return firstSetOf(def.parser, new Set(), rr, this.activeTrivia)
         })
         const gateFirst = finalChoice.firstSets.map((first, i) => transactionalFirst[i] ?? first)
         const classes = gateFirst.map((first, i) => finalChoice.nullable[i] && transactionalFirst[i] === undefined
@@ -1239,7 +1241,7 @@ class Encoder {
         const rr = this.refResolver()
         const itemClass = matchesEmpty(d.parser, new Set(), rr)
           ? -1
-          : this.existingCharClass(firstSetOf(d.parser, new Set(), rr))
+          : this.existingCharClass(firstSetOf(d.parser, new Set(), rr, this.activeTrivia))
         const op = d.valueUnused ? OP_REPV : OP_REP
         const min = d.tag === 'many' ? 0 : d.min
         // ip + 6 is the ITEM's expected set and ip + 7 the separator's sentinel
@@ -1274,7 +1276,7 @@ class Encoder {
         if (this.rec) {
           return this.emit(
             OP_REP, child, d.min, d.max ?? -1, sep, flags,
-            this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver())),
+            this.expected(deriveExpected(d.parser)), this.charClass(firstSetOf(d.separator, new Set(), this.refResolver(), this.activeTrivia)),
           )
         }
         return d.min >= 2
@@ -1411,7 +1413,7 @@ class Encoder {
         // not). Resolve the ref's gate through `winners`, exactly as the `lazy` case
         // resolves the call. Non-ref bodies keep the cached set (byte-identical).
         const fs = d.parser._def.tag === 'lazy'
-          ? firstSetOf(d.parser, new Set(), this.refResolver())
+          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
           : d.parser._meta.firstSet
         if (fs.kind === 'any') return body
         const cls = this.charClass(fs)
@@ -1605,7 +1607,7 @@ class Encoder {
         // Same override-aware resolution as the node gate: a bare-ref inner resolves
         // its gate through `winners` so a widened winner is not gated out.
         const fs = d.parser._def.tag === 'lazy'
-          ? firstSetOf(d.parser, new Set(), this.refResolver())
+          ? firstSetOf(d.parser, new Set(), this.refResolver(), this.activeTrivia)
           : d.parser._meta.firstSet
         if (fs.kind === 'any' || matchesEmpty(d.parser)) return inner
         const cls = this.charClass(fs)

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.5'
+export const PARSEMAN_VERSION = '0.50.7'