parseman 0.48.1 → 0.50.0

package/src/plugin/entry-supercompiler.ts

@@ -0,0 +1,567 @@
+/**
+ * Experimental build-time Entry/SCC supercompiler for static table assemblies.
+ *
+ * The table emitter remains the sole semantic backend.  This pass parses that
+ * backend's ordinary JavaScript and joins uniquely-owned piece functions with
+ * labelled blocks.  It never evaluates source and it never recognizes grammar
+ * names or reducer text.  Public entries, value references, shared joins,
+ * recursive SCCs, and effect rows are exact outline barriers.
+ */
+import { parseSync } from 'oxc-parser'
+import { OP_ATTEMPT, OP_NODE, OP_NODE_TRACK, OP_REPV, OP_SCAN } from '../table/ops.ts'
+import { emitAssemblySource, type EmitResult } from '../table/emit-assembly.ts'
+import { defaultAssemblyCfgs } from '../table/emit.ts'
+import { resolveTable, type TableProgram } from '../table/program.ts'
+
+type Ast = { type: string; start?: number; end?: number; [key: string]: unknown }
+
+export type EntrySupercompileCfg = {
+  readonly hostCst: boolean
+  readonly hostReadsChildren?: boolean
+  readonly hostCaptureTrivia?: ((type: string) => boolean) | undefined
+  readonly trackLines: boolean
+  readonly tolerant: boolean
+  readonly coverage: boolean
+  readonly probe: boolean
+}
+
+export type EntrySupercompileStats = {
+  readonly activated: boolean
+  readonly reason?: string
+  readonly functionsBefore: number
+  readonly functionsAfter: number
+  readonly pieceCallsBefore: number
+  readonly pieceCallsAfter: number
+  readonly sourceBefore: number
+  readonly sourceAfter: number
+  readonly regions: number
+  readonly largestRegionSource: number
+  readonly largestRegionIp?: number
+  readonly protocolRegions: Readonly<{ node: number; repv: number; nodeAndRepv: number }>
+  readonly barriers: Readonly<Record<string, number>>
+}
+
+export type EntrySupercompileResult = EmitResult & { readonly supercompile: EntrySupercompileStats }
+
+type Fn = {
+  readonly ip: number
+  readonly name: string
+  readonly node: Ast
+  readonly body: Ast
+  readonly calls: Call[]
+}
+
+type Call = {
+  readonly caller: number
+  readonly callee: number
+  readonly node: Ast
+  readonly statement: Ast
+  readonly args: readonly Ast[]
+  readonly transformable: boolean
+}
+
+type Edit = { readonly start: number; readonly end: number; readonly text: string }
+
+const PIECE = /^_pf(\d+)$/
+const WRAP = 'function __parseman_supercompile__(){\n'
+const SUFFIX = '\n}'
+
+function ast(value: unknown): Ast | undefined {
+  return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Ast : undefined
+}
+
+function nodes(value: unknown): Ast[] {
+  return Array.isArray(value) ? value.filter(v => ast(v) !== undefined) as Ast[] : []
+}
+
+function nameOf(node: Ast | undefined): string | undefined {
+  return node?.type === 'Identifier' && typeof node.name === 'string' ? node.name : undefined
+}
+
+function range(node: Ast): { start: number; end: number } {
+  if (typeof node.start !== 'number' || typeof node.end !== 'number') throw new Error('entry supercompiler: AST node without range')
+  return { start: node.start - WRAP.length, end: node.end - WRAP.length }
+}
+
+function children(node: Ast): Ast[] {
+  const out: Ast[] = []
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'type' || key === 'start' || key === 'end') continue
+    if (Array.isArray(value)) {
+      for (const child of value) {
+        const c = ast(child)
+        if (c !== undefined) out.push(c)
+      }
+    } else {
+      const c = ast(value)
+      if (c !== undefined) out.push(c)
+    }
+  }
+  return out
+}
+
+function isFunction(node: Ast): boolean {
+  return node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression'
+}
+
+function isDirectCallUse(call: Ast, parent: Ast | undefined, statement: Ast): boolean {
+  if (parent === undefined) return false
+  if (parent.type === 'VariableDeclarator') {
+    const declarations = statement.type === 'VariableDeclaration' ? nodes(statement.declarations) : []
+    return declarations.length === 1 && declarations[0] === parent && parent.init === call
+  }
+  if (parent.type === 'AssignmentExpression') {
+    return statement.type === 'ExpressionStatement' && statement.expression === parent
+      && nameOf(ast(parent.left)) !== undefined && parent.right === call && parent.operator === '='
+  }
+  if (parent.type === 'ReturnStatement') return statement === parent && parent.argument === call
+  return false
+}
+
+function isListStatement(statement: Ast, parent: Ast | undefined): boolean {
+  if (parent?.type === 'BlockStatement') return nodes(parent.body).includes(statement)
+  if (parent?.type === 'SwitchCase') return nodes(parent.consequent).includes(statement)
+  return false
+}
+
+function hasInlineScopeHazard(fn: Fn): boolean {
+  if (fn.node.async === true || fn.node.generator === true) return true
+  let hazard = false
+  const walk = (node: Ast): void => {
+    if (hazard) return
+    if (node.type === 'Identifier' && node.name === 'arguments') hazard = true
+    else if (node.type === 'ThisExpression') hazard = true
+    else if (node.type === 'VariableDeclaration' && node.kind === 'var') hazard = true
+    else if (node.type === 'MetaProperty'
+      && nameOf(ast(node.meta)) === 'new' && nameOf(ast(node.property)) === 'target') hazard = true
+    else for (const child of children(node)) walk(child)
+  }
+  walk(fn.body)
+  return hazard
+}
+
+function hasInlineSignature(fn: Fn): boolean {
+  const params = nodes(fn.node.params)
+  return params.length === 3
+    && nameOf(params[0]) === 'input'
+    && nameOf(params[1]) === 'pos'
+    && nameOf(params[2]) === 'ctx'
+}
+
+function render(source: string, start: number, end: number, edits: readonly Edit[]): string {
+  const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end)
+  let at = start
+  let out = ''
+  for (const edit of ordered) {
+    if (edit.start < at || edit.end < edit.start || edit.start < start || edit.end > end) {
+      throw new Error('entry supercompiler: overlapping or out-of-range structured edit')
+    }
+    out += source.slice(at, edit.start) + edit.text
+    at = edit.end
+  }
+  return out + source.slice(at, end)
+}
+
+/** Tarjan over the actual emitted piece-call graph. */
+function recursiveMembers(fns: ReadonlyMap<number, Fn>): Set<number> {
+  let next = 0
+  const index = new Map<number, number>()
+  const low = new Map<number, number>()
+  const stack: number[] = []
+  const on = new Set<number>()
+  const recursive = new Set<number>()
+  const visit = (ip: number): void => {
+    index.set(ip, next); low.set(ip, next); next++
+    stack.push(ip); on.add(ip)
+    for (const call of fns.get(ip)?.calls ?? []) {
+      if (!fns.has(call.callee)) continue
+      if (!index.has(call.callee)) {
+        visit(call.callee)
+        low.set(ip, Math.min(low.get(ip)!, low.get(call.callee)!))
+      } else if (on.has(call.callee)) low.set(ip, Math.min(low.get(ip)!, index.get(call.callee)!))
+    }
+    if (low.get(ip) !== index.get(ip)) return
+    const component: number[] = []
+    for (;;) {
+      const member = stack.pop()!
+      on.delete(member); component.push(member)
+      if (member === ip) break
+    }
+    if (component.length > 1 || component.some(member => fns.get(member)!.calls.some(c => c.callee === member))) {
+      for (const member of component) recursive.add(member)
+    }
+  }
+  for (const ip of fns.keys()) if (!index.has(ip)) visit(ip)
+  return recursive
+}
+
+function fallback(emitted: EmitResult, reason: string, before: Omit<EntrySupercompileStats, 'activated' | 'reason' | 'functionsAfter' | 'pieceCallsAfter' | 'sourceAfter' | 'regions' | 'largestRegionSource' | 'largestRegionIp' | 'protocolRegions'>): EntrySupercompileResult {
+  return {
+    ...emitted,
+    supercompile: {
+      ...before, activated: false, reason,
+      functionsAfter: before.functionsBefore,
+      pieceCallsAfter: before.pieceCallsBefore,
+      sourceAfter: before.sourceBefore,
+      regions: before.functionsBefore,
+      largestRegionSource: 0,
+      protocolRegions: { node: 0, repv: 0, nodeAndRepv: 0 },
+    },
+  }
+}
+
+/**
+ * Emit and structurally join one static assembly.  `extraIps` are the same
+ * externally-addressable scan roots passed to the canonical emitter.
+ */
+export function supercompileEntryAssembly(
+  prog: TableProgram,
+  cfg: EntrySupercompileCfg,
+  extraIps: readonly number[] = [],
+): EntrySupercompileResult {
+  const emitted = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true)
+  return supercompileEmittedAssembly(prog, cfg, extraIps, emitted)
+}
+
+/**
+ * Plugin-only final splice for an ordinary macro replacement. The table
+ * compiler emits its canonical callback-free public artifact first; this pass
+ * then finds the precompiled assembly through the table object's AST shape and
+ * replaces only that factory body. Any mismatch returns the canonical source.
+ */
+export function supercompileRuleMapReplacement(prog: TableProgram, replacement: string): string {
+  const cfg = defaultAssemblyCfgs(prog)[0]
+  if (cfg === undefined) return replacement
+  const extraIps: number[] = []
+  for (const scan of prog.scans ?? []) {
+    for (const ref of scan.skip) extraIps.push(ref[0])
+    if (scan.sentinel !== undefined) extraIps.push(scan.sentinel[0])
+  }
+  for (const set of prog.scanSkip ?? []) for (const ref of set) extraIps.push(ref[0])
+
+  let canonical: EmitResult
+  let candidate: EntrySupercompileResult
+  try {
+    canonical = emitAssemblySource(resolveTable(prog), prog, cfg, extraIps, true)
+    candidate = supercompileEmittedAssembly(prog, cfg, extraIps, canonical)
+  } catch {
+    return replacement
+  }
+  if (!candidate.supercompile.activated) return replacement
+
+  const prefix = 'const __parseman_macro_replacement__='
+  const parsed = parseSync('parseman-entry-supercompile-replacement.js', prefix + replacement)
+  if (parsed.errors.length > 0) return replacement
+  const program = parsed.program as unknown as Ast
+  const declaration = nodes(program.body)[0]
+  const declarator = nodes(declaration?.declarations)[0]
+  const call = ast(declarator?.init)
+  const table = nodes(call?.arguments)[0]
+  if (declaration?.type !== 'VariableDeclaration' || declarator?.type !== 'VariableDeclarator'
+    || call?.type !== 'CallExpression' || table?.type !== 'ObjectExpression') return replacement
+
+  const property = (object: Ast, key: string): Ast | undefined => nodes(object.properties).find(prop =>
+    prop.type === 'Property' && nameOf(ast(prop.key)) === key)
+  const assembliesProp = property(table, 'a')
+  const assemblies = nodes(ast(assembliesProp?.value)?.elements)
+  if (assembliesProp === undefined || assemblies.length !== 1 || assemblies[0]?.type !== 'ObjectExpression') return replacement
+  const factoryProp = property(assemblies[0]!, 'factory')
+  const factory = ast(factoryProp?.value)
+  const body = ast(factory?.body)
+  if (factory?.type !== 'FunctionExpression' || body?.type !== 'BlockStatement') return replacement
+  if (typeof body.start !== 'number' || typeof body.end !== 'number') return replacement
+  const start = body.start - prefix.length + 1
+  const end = body.end - prefix.length - 1
+  if (replacement.slice(start, end) !== canonical.source + '\n') return replacement
+  const transformed = replacement.slice(0, start) + candidate.source + '\n' + replacement.slice(end)
+  const checked = parseSync('parseman-entry-supercompile-replacement-result.js', prefix + transformed)
+  return checked.errors.length === 0 ? transformed : replacement
+}
+
+/** Build-hook form: transform the exact canonical source already selected. */
+export function supercompileEmittedAssembly(
+  prog: TableProgram,
+  _cfg: EntrySupercompileCfg,
+  extraIps: readonly number[],
+  emitted: EmitResult,
+): EntrySupercompileResult {
+  const source = emitted.source
+  const parsed = parseSync('parseman-entry-supercompile.js', WRAP + source + SUFFIX)
+  if (parsed.errors.length > 0) {
+    const zero = { functionsBefore: 0, pieceCallsBefore: 0, sourceBefore: source.length, barriers: {} }
+    return fallback(emitted, 'canonical emitted source did not parse', zero)
+  }
+  const program = parsed.program as unknown as Ast
+  const wrapper = nodes(program.body)[0]
+  const wrapperBody = ast(wrapper?.body)
+  if (wrapper?.type !== 'FunctionDeclaration' || wrapperBody?.type !== 'BlockStatement') {
+    const zero = { functionsBefore: 0, pieceCallsBefore: 0, sourceBefore: source.length, barriers: {} }
+    return fallback(emitted, 'missing compiler wrapper', zero)
+  }
+
+  const fns = new Map<number, Fn>()
+  for (const statement of nodes(wrapperBody.body)) {
+    if (statement.type !== 'FunctionDeclaration') continue
+    const name = nameOf(ast(statement.id))
+    const hit = name === undefined ? undefined : PIECE.exec(name)
+    const body = ast(statement.body)
+    if (hit !== undefined && hit !== null && body?.type === 'BlockStatement') {
+      const ip = Number(hit[1])
+      fns.set(ip, { ip, name: name!, node: statement, body, calls: [] })
+    }
+  }
+
+  const externalRefs = new Set<number>()
+  let reservedCollision = false
+  const allCalls: Call[] = []
+  const walk = (
+    node: Ast,
+    current: Fn | undefined,
+    parent: Ast | undefined,
+    statement: Ast | undefined,
+    statementParent: Ast | undefined,
+  ): void => {
+    if (isFunction(node) && node !== current?.node) {
+      const own = node.type === 'FunctionDeclaration' ? nameOf(ast(node.id)) : undefined
+      const hit = own === undefined ? undefined : PIECE.exec(own)
+      if (hit !== undefined && hit !== null) {
+        const fn = fns.get(Number(hit[1]))
+        if (fn !== undefined) {
+          for (const child of children(node)) {
+            if (child !== ast(node.id)) walk(child, fn, node, undefined, undefined)
+          }
+          return
+        }
+      }
+      // Non-piece closures may retain piece values.  They are external roots;
+      // do not treat their returns as exits from a piece being joined.
+      current = undefined
+    }
+
+    let owner = statement
+    let ownerParent = statementParent
+    if (parent?.type === 'BlockStatement' && nodes(parent.body).includes(node)) { owner = node; ownerParent = parent }
+    if (parent?.type === 'SwitchCase' && nodes(parent.consequent).includes(node)) { owner = node; ownerParent = parent }
+
+    if (node.type === 'CallExpression') {
+      const calleeName = nameOf(ast(node.callee))
+      const hit = calleeName === undefined ? undefined : PIECE.exec(calleeName)
+      if (hit !== undefined && hit !== null) {
+        const callee = Number(hit[1])
+        const args = nodes(node.arguments)
+        const transformable = current !== undefined && owner !== undefined && args.length === 3
+          && nameOf(args[0]) === 'input' && nameOf(args[2]) === 'ctx'
+          && isDirectCallUse(node, parent, owner) && isListStatement(owner, ownerParent)
+        if (current === undefined || owner === undefined) externalRefs.add(callee)
+        else {
+          const call = { caller: current.ip, callee, node, statement: owner, args, transformable }
+          current.calls.push(call); allCalls.push(call)
+        }
+      }
+    }
+    if (node.type === 'Identifier') {
+      if (typeof node.name === 'string' && /^_z\d/.test(node.name)) reservedCollision = true
+      const hit = typeof node.name === 'string' ? PIECE.exec(node.name) : null
+      if (hit !== null) {
+        const isDecl = parent?.type === 'FunctionDeclaration' && parent.id === node
+        const isCall = parent?.type === 'CallExpression' && parent.callee === node
+        if (!isDecl && !isCall) externalRefs.add(Number(hit[1]))
+      }
+    }
+    for (const child of children(node)) walk(child, current, node, owner, ownerParent)
+  }
+  for (const statement of nodes(wrapperBody.body)) walk(statement, undefined, wrapperBody, undefined, undefined)
+
+  if (reservedCollision) {
+    const before = { functionsBefore: fns.size, pieceCallsBefore: allCalls.length, sourceBefore: source.length, barriers: { name: 1 } }
+    return fallback(emitted, 'canonical source uses the reserved _z<N> supercompiler prefix', before)
+  }
+
+  const pieceCallsBefore = allCalls.length
+  const recursive = recursiveMembers(fns)
+  const incoming = new Map<number, Call[]>()
+  for (const call of allCalls) {
+    const list = incoming.get(call.callee) ?? []
+    list.push(call); incoming.set(call.callee, list)
+  }
+  const publicRoots = new Set([...Object.values(prog.rules), ...extraIps])
+  const barrier = new Map<number, string>()
+  for (const ip of fns.keys()) {
+    // Context-saving TOKEN/LEAF/DISPATCH/SCOPE rows and REP loops are
+    // self-contained structured control. ATTEMPT can re-anchor failure state,
+    // while SCAN can invoke an interpreted parser, so neither effect may cross
+    // an outlined-region boundary.
+    if (publicRoots.has(ip) || externalRefs.has(ip)) barrier.set(ip, 'public')
+    else if (recursive.has(ip)) barrier.set(ip, 'recursive')
+    else if (prog.code[ip] === OP_ATTEMPT || prog.code[ip] === OP_SCAN) barrier.set(ip, 'effect')
+    else if (hasInlineScopeHazard(fns.get(ip)!)) barrier.set(ip, 'scope')
+    else if (!hasInlineSignature(fns.get(ip)!)) barrier.set(ip, 'shape')
+    else if ((incoming.get(ip)?.length ?? 0) !== 1) barrier.set(ip, 'shared')
+    else if (!incoming.get(ip)![0]!.transformable) barrier.set(ip, 'shape')
+  }
+
+  const roots = [...fns.keys()].filter(ip => barrier.has(ip))
+  const owner = new Map<number, number>()
+  const absorb = (ip: number, root: number): void => {
+    if (owner.has(ip)) return
+    owner.set(ip, root)
+    for (const call of fns.get(ip)?.calls ?? []) {
+      if (!fns.has(call.callee) || barrier.has(call.callee) || !call.transformable) continue
+      absorb(call.callee, root)
+    }
+  }
+  for (const root of roots) absorb(root, root)
+  for (const ip of fns.keys()) if (!owner.has(ip)) { barrier.set(ip, 'shared'); absorb(ip, ip) }
+
+  let serial = 0
+  const src = (node: Ast): string => { const r = range(node); return source.slice(r.start, r.end) }
+  const renderBody = (ip: number, embedded: { result: string; label: string } | undefined): string => {
+    const fn = fns.get(ip)!
+    const bodyRange = range(fn.body)
+    const start = bodyRange.start + 1
+    const end = bodyRange.end - 1
+    const edits: Edit[] = []
+    const callsByStatement = new Map<Ast, Call[]>()
+    for (const call of fn.calls) {
+      if (owner.get(call.callee) !== owner.get(ip) || barrier.has(call.callee) || !call.transformable) continue
+      const list = callsByStatement.get(call.statement) ?? []
+      list.push(call); callsByStatement.set(call.statement, list)
+    }
+    const returns: Ast[] = []
+    const collectReturns = (node: Ast): void => {
+      if (node !== fn.body && isFunction(node)) return
+      if (node.type === 'ReturnStatement') returns.push(node)
+      for (const child of children(node)) collectReturns(child)
+    }
+    if (embedded !== undefined) collectReturns(fn.body)
+
+    const callPrefix = (call: Call): { prefix: string; value: string } => {
+      const id = serial++
+      const result = `_z${id}r`
+      const label = `_z${id}`
+      const at = `_z${id}p`
+      const nested = renderBody(call.callee, { result, label })
+      return {
+        value: result,
+        prefix: `let ${result},${at}=${src(call.args[1]!)}\n${label}:{let pos=${at}\n${nested}\n}\n`,
+      }
+    }
+
+    for (const [statement, calls] of callsByStatement) {
+      let prefix = ''
+      const replacements: Edit[] = []
+      for (const call of calls) {
+        const made = callPrefix(call)
+        prefix += made.prefix
+        const cr = range(call.node)
+        replacements.push({ start: cr.start, end: cr.end, text: made.value })
+      }
+      if (statement.type === 'ReturnStatement' && embedded !== undefined) {
+        const sr = range(statement)
+        const arg = ast(statement.argument)
+        const value = arg === undefined ? 'undefined' : render(source, range(arg).start, range(arg).end, replacements)
+        edits.push({ start: sr.start, end: sr.end, text: `{${prefix}${embedded.result}=${value};break ${embedded.label}}` })
+      } else {
+        const sr = range(statement)
+        edits.push({ start: sr.start, end: sr.start, text: prefix })
+        edits.push(...replacements)
+      }
+    }
+    if (embedded !== undefined) {
+      for (const statement of returns) {
+        if (callsByStatement.has(statement)) continue
+        const sr = range(statement)
+        const arg = ast(statement.argument)
+        edits.push({
+          start: sr.start, end: sr.end,
+          text: `{${embedded.result}=${arg === undefined ? 'undefined' : src(arg)};break ${embedded.label}}`,
+        })
+      }
+    }
+    return render(source, start, end, edits)
+  }
+
+  const regionSizes = new Map<number, number>()
+  const regionProtocol = new Map<number, number>()
+  for (const [ip, root] of owner) {
+    const r = range(fns.get(ip)!.node)
+    regionSizes.set(root, (regionSizes.get(root) ?? 0) + r.end - r.start)
+    const op = prog.code[ip]
+    const bits = (op === OP_NODE || op === OP_NODE_TRACK ? 1 : 0) | (op === OP_REPV ? 2 : 0)
+    regionProtocol.set(root, (regionProtocol.get(root) ?? 0) | bits)
+  }
+  const oversized = new Set<number>()
+  for (const [ip, size] of regionSizes) if (size > 180_000) oversized.add(ip)
+  if (oversized.size > 0) {
+    const counts = Object.fromEntries([...barrier.values()].map(k => [k, 0]))
+    for (const kind of barrier.values()) counts[kind] = (counts[kind] ?? 0) + 1
+    const before = { functionsBefore: fns.size, pieceCallsBefore, sourceBefore: source.length, barriers: counts }
+    return fallback(emitted, 'a region exceeded the 180KB source cap', before)
+  }
+
+  const topEdits: Edit[] = []
+  for (const [ip, fn] of fns) {
+    if (owner.get(ip) === ip) {
+      const br = range(fn.body)
+      topEdits.push({ start: br.start + 1, end: br.end - 1, text: renderBody(ip, undefined) })
+    } else {
+      const fr = range(fn.node)
+      topEdits.push({ start: fr.start, end: fr.end, text: '' })
+    }
+  }
+  const candidate = render(source, 0, source.length, topEdits)
+  const counts: Record<string, number> = {}
+  for (const kind of barrier.values()) counts[kind] = (counts[kind] ?? 0) + 1
+  const before = { functionsBefore: fns.size, pieceCallsBefore, sourceBefore: source.length, barriers: counts }
+  if (candidate.length > Math.ceil(source.length * 1.05)) {
+    return fallback(emitted, `candidate exceeded the 5% total source cap (${candidate.length} > ${Math.ceil(source.length * 1.05)})`, before)
+  }
+  const functionsAfter = roots.length
+  const removed = fns.size - functionsAfter
+  // Parse the RESULT, not merely the input. A range bug (notably a UTF-8 byte
+  // offset mistaken for a JS UTF-16 index) or a malformed labelled exit must
+  // fail closed before one byte is serialized. Then prove every remaining
+  // piece identifier has a declaration: internal bodies are suppressed only
+  // after this reachable-reference relink check.
+  const checked = parseSync('parseman-entry-supercompile-result.js', WRAP + candidate + SUFFIX)
+  if (checked.errors.length > 0) return fallback(emitted, 'structured candidate did not parse', before)
+  const declared = new Set<string>()
+  const referenced = new Set<string>()
+  const checkRefs = (node: Ast, parent?: Ast): void => {
+    if (node.type === 'FunctionDeclaration') {
+      const name = nameOf(ast(node.id))
+      if (name !== undefined && PIECE.test(name)) declared.add(name)
+    }
+    if (node.type === 'Identifier' && typeof node.name === 'string' && PIECE.test(node.name)) {
+      const isDeclaration = parent?.type === 'FunctionDeclaration' && parent.id === node
+      if (!isDeclaration) referenced.add(node.name)
+    }
+    for (const child of children(node)) checkRefs(child, node)
+  }
+  checkRefs(checked.program as unknown as Ast)
+  if (declared.size !== functionsAfter || [...referenced].some(name => !declared.has(name))) {
+    return fallback(emitted, 'deleted piece body remains reachable after structured relinking', before)
+  }
+  const largestRegion = [...regionSizes].sort((a, b) => b[1] - a[1])[0]
+  const protocolRegions = {
+    node: [...regionProtocol.values()].filter(bits => (bits & 1) !== 0).length,
+    repv: [...regionProtocol.values()].filter(bits => (bits & 2) !== 0).length,
+    nodeAndRepv: [...regionProtocol.values()].filter(bits => bits === 3).length,
+  }
+  return {
+    ...emitted,
+    source: candidate,
+    supercompile: {
+      ...before,
+      activated: removed > 0,
+      ...(removed > 0 ? {} : { reason: 'no uniquely-owned region bodies' }),
+      functionsAfter,
+      pieceCallsAfter: pieceCallsBefore - removed,
+      sourceAfter: candidate.length,
+      regions: roots.length,
+      largestRegionSource: Math.max(0, ...regionSizes.values()),
+      ...(largestRegion === undefined ? {} : { largestRegionIp: largestRegion[0] }),
+      protocolRegions,
+    },
+  }
+}

package/src/plugin/evaluator.ts

@@ -18,7 +18,8 @@ import type { DispatchArm } from '../combinators/dispatch.ts'
 import { ref } from '../combinators/ref.ts'
 import { rules, type RulesOptions } from '../combinators/parser.ts'
 import * as parseman from '../index.ts'
-import { directBuilderUnsupportedBindings } from './direct-builder-static.ts'
+import { confirmedBuildParamUnused } from '../compiler/build-arity.ts'
+import { directBuilderBindings } from './direct-builder-static.ts'
 import type { ReducerResolver } from './reducer-resolver.ts'
 
 /**
@@ -124,6 +125,20 @@ export function setReducerResolver(r: ReducerResolver | null, entrySource: strin
   _entrySource = entrySource
 }
 
+/**
+ * Map a free lexical name read by a direct node builder to the import it came from
+ * in the AUTHORING module. A name that resolves is no longer a refusal — the node
+ * carries `{ source, imported }` provenance, and a downstream `compose()` re-binds
+ * it by re-emitting the same import into the consuming module. A name that does not
+ * resolve (a module-private const, a genuinely undefined read) stays a refusal.
+ */
+export type BuilderImportResolver = (name: string) => { source: string; imported: string } | null
+let _builderImports: BuilderImportResolver | null = null
+/** Install (or clear, with `null`) the import-provenance resolver for the module being transformed. */
+export function setBuilderImportResolver(r: BuilderImportResolver | null): void {
+  _builderImports = r
+}
+
 // ---------------------------------------------------------------------------
 // Scope types
 //
@@ -660,6 +675,7 @@ function exprToCombi(node: Expression, scope: XScope, code?: string, mfs?: strin
         ? parseman.node(explicitType, inner, hasBuild ? () => null : undefined, opts as parseman.NodeOptions | undefined)
         : parseman.node(inner, hasBuild ? () => null : undefined, opts as parseman.NodeOptions | undefined)
       if (combi._def.tag === 'node' && buildSrc !== undefined) {
+        const authorDeclaredBuildArity = opts?.buildArity !== undefined
         combi._def.buildSrc = buildSrc
         // The type argument's IDENTIFIER, when it was written as one. A `node(type, …)`
         // inside a factory resolves `type` to a string here, which loses the fact that
@@ -700,8 +716,50 @@ function exprToCombi(node: Expression, scope: XScope, code?: string, mfs?: strin
           if (combi._def.buildArity === undefined && resolved.arity !== null) combi._def.buildArity = resolved.arity
           if (resolved.reason !== undefined) combi._def.buildArityUnresolved = resolved.reason
         }
-        const staticError = directBuilderUnsupportedBindings(buildSrc)
+        // Analyze the REDUCER BODY, not the call-site reference. A named `function`
+        // reducer (`node(..., foldOperation)`) arrives here as the bare identifier
+        // `foldOperation`, which the analyzer can only read as `unsupported callback
+        // shape`. `buildSigSrc` is the resolved declaration source (see the resolver
+        // above and `buildAnalysisSrc`), so preferring it lets the function-reducer
+        // lift walk the real body and report its real free names. An inline builder
+        // has no `buildSigSrc`, so this is exactly `buildSrc` for that case.
+        const analysisSrc = combi._def.buildSigSrc ?? buildSrc
+        // Arity answers which positional slots the author/compiler promises to
+        // supply; reducer liveness answers whether one of those values is actually
+        // observable. Only macro-resolved source can establish the latter. An
+        // explicit buildArity remains authority: it is a user declaration, not a
+        // compiler invitation to reinterpret the callback body.
+        if (!authorDeclaredBuildArity && confirmedBuildParamUnused(analysisSrc, 3)) {
+          combi._def.buildRawUnused = true
+        }
+        const report = directBuilderBindings(analysisSrc)
+        // Import-provenance rescue and free-name refusals apply ONLY to an INLINE
+        // builder body, whose source (`buildSrc`) is exactly what the table inlines and
+        // a downstream compose re-emits verbatim. A NAMED reducer (`buildSigSrc` set —
+        // `node(..., foldOperation)`) is emitted as a live `f:[foldOperation]` binding
+        // that runs in ITS OWN module's scope; its body is never inlined here. So its
+        // body's free names are not this (entry) module's to resolve — doing so bound a
+        // coincidental same-named entry import to the wrong helper (wrong provenance) —
+        // and carrying their imports is dead: the emitted source is the NAME, not the
+        // body, so re-emitting those imports satisfies nothing. Analyse-only fields
+        // (`buildArity`/`buildSigSrc`) are already set above and are unaffected.
+        const isInlineBuilder = combi._def.buildSigSrc === undefined
+        // A free name that this module IMPORTED is not a refusal: carry its
+        // provenance so a downstream compose() re-emits the import. Only structural
+        // refusals and free names with NO import provenance become the fail-closed
+        // `buildStaticError` — which the runtime re-lowerer still throws on.
+        const carriedImports: Array<{ local: string; source: string; imported: string }> = []
+        const unresolved: string[] = []
+        if (isInlineBuilder) {
+          for (const name of report.free) {
+            const prov = _builderImports?.(name) ?? null
+            if (prov) carriedImports.push({ local: name, source: prov.source, imported: prov.imported })
+            else unresolved.push(name)
+          }
+        }
+        const staticError = [...report.structural, ...unresolved]
         if (staticError.length > 0) combi._def.buildStaticError = staticError
+        if (carriedImports.length > 0) combi._def.buildImports = carriedImports
       }
       return combi
     } catch { return null }