jz 0.2.1 → 0.3.1

package/src/compile.js

@@ -32,38 +32,31 @@ import {
   analyzePtrUnboxable, typedElemAux, invalidateLocalsCache,
   analyzeBoxedCaptures, updateRep, inferStringParams,
 } from './analyze.js'
-import { optimizeFunc, hoistConstantPool, specializeMkptr, specializePtrBase, sortStrPoolByFreq, treeshake, arenaRewindModule } from './optimize.js'
+import { optimizeFunc, treeshake } from './optimize.js'
 import { emit, emitter, emitFlat, emitBody } from './emit.js'
 import {
   typed, asF64, asI32, asPtrOffset, asParamType, toI32, asI64, fromI64,
   NULL_NAN, UNDEF_NAN, NULL_WAT, UNDEF_WAT, NULL_IR, UNDEF_IR, nullExpr, undefExpr,
-  MAX_CLOSURE_ARITY, MEM_OPS, WASM_OPS, SPREAD_MUTATORS, BOXED_MUTATORS,
-  mkPtrIR, ptrOffsetIR, ptrTypeIR, extractF64Bits, appendStaticSlots,
-  isLit, litVal, isNullishLit, isPureIR, isPostfix, emitNum,
-  temp, tempI32, tempI64, f64rem, toNumF64, truthyIR, toBoolFromEmitted,
-  keyValType, usesDynProps, needsDynShadow,
+  MAX_CLOSURE_ARITY,
+  mkPtrIR,
+  isLit, litVal, isNullishLit, emitNum,
+  temp,
   isGlobal, isConst, boxedAddr, readVar, writeVar, isNullish, isUndef,
   slotAddr, elemLoad, elemStore, arrayLoop, allocPtr,
   multiCount, loopTop, flat, reconstructArgsWithSpreads,
-  valKindToPtr,
+  valKindToPtr, findBodyStart,
 } from './ir.js'
 import plan from './plan.js'
+import {
+  buildStartFn, dedupClosureBodies, finalizeClosureTable,
+  pullStdlib, syncImports, optimizeModule, stripStaticDataPrefix,
+} from './assemble.js'
 
 const timePhase = (profiler, name, fn) => profiler ? profiler.time(name, fn) : fn()
 
 // Per-compile func name set + map live on ctx.func.names / ctx.func.map,
 // populated at compile() entry. Both reset by ctx.js reset() and re-filled here.
 
-// NaN-prefix top-13-bits as BigInt — used by the static-prefix-strip pass
-// below to identify pointer slots in the data segment.
-const NAN_PREFIX = BigInt(LAYOUT.NAN_PREFIX)
-const TAG_MASK_BIG = BigInt(LAYOUT.TAG_MASK)
-const AUX_MASK_BIG = BigInt(LAYOUT.AUX_MASK)
-const OFFSET_MASK_BIG = BigInt(LAYOUT.OFFSET_MASK)
-const TAG_SHIFT_BIG = BigInt(LAYOUT.TAG_SHIFT)
-const AUX_SHIFT_BIG = BigInt(LAYOUT.AUX_SHIFT)
-const SSO_BIT_BIG = BigInt(LAYOUT.SSO_BIT)
-
 // Low-level IR helpers previously lived here. Pure ones moved to src/ir.js;
 // emit-calling ones (toBool, emitTypeofCmp, emitDecl, materializeMulti,
 // buildArrayWithSpreads) moved to src/emit.js.
@@ -145,95 +138,6 @@ const tcoTailRewrite = (ir, resultType) => {
   return ir
 }
 
-const ARENA_SAFE_CALLS = new Set([
-  '$__alloc', '$__alloc_hdr', '$__mkptr',
-  '$__ptr_offset', '$__ptr_type', '$__ptr_aux',
-  '$__len', '$__cap', '$__typed_shift', '$__typed_data',
-])
-
-const findFuncBodyStart = (fn) => {
-  for (let i = 2; i < fn.length; i++) {
-    const n = fn[i]
-    if (Array.isArray(n) && (n[0] === 'param' || n[0] === 'result' || n[0] === 'local' || n[0] === 'export')) continue
-    return i
-  }
-  return fn.length
-}
-
-const heapGetIR = () => ctx.memory.shared
-  ? ['i32.load', ['i32.const', 1020]]
-  : ['global.get', '$__heap']
-
-const heapSetIR = value => ctx.memory.shared
-  ? ['i32.store', ['i32.const', 1020], value]
-  : ['global.set', '$__heap', value]
-
-function applyArenaRewind(func, fn, safeCallees) {
-  if (ctx.transform.optimize?.arenaRewind === false) return false
-  if (func.raw || func.sig.params.length !== 0 || func.sig.results.length !== 1) return false
-  if (func.sig.ptrKind != null) return false
-  if (func.sig.results[0] === 'f64' && func.valResult !== VAL.NUMBER) return false
-  if (func.sig.results[0] !== 'f64' && func.sig.results[0] !== 'i32') return false
-
-  const bodyStart = findFuncBodyStart(fn)
-  let hasAlloc = false
-  let unsafe = false
-  const scan = node => {
-    if (unsafe || !Array.isArray(node)) return
-    const op = node[0]
-    if (op === 'global.set' || op === 'return_call' || op === 'call_indirect' || op === 'call_ref') {
-      unsafe = true
-      return
-    }
-    if (op === 'call') {
-      const name = node[1]
-      if (name === '$__alloc' || name === '$__alloc_hdr') hasAlloc = true
-      if (!(safeCallees ?? ARENA_SAFE_CALLS).has(name)) {
-        unsafe = true
-        return
-      }
-    }
-    for (let i = 1; i < node.length; i++) scan(node[i])
-  }
-  for (let i = bodyStart; i < fn.length; i++) scan(fn[i])
-  if (unsafe || !hasAlloc) return false
-
-  let id = 0
-  const hasLocal = name => fn.some(n => Array.isArray(n) && n[0] === 'local' && n[1] === name)
-  while (hasLocal(`$${T}heap_save${id}`) || hasLocal(`$${T}arena_ret${id}`)) id++
-  const save = `$${T}heap_save${id}`
-  const ret = `$${T}arena_ret${id}`
-  const restore = () => heapSetIR(['local.get', save])
-  const resultType = func.sig.results[0]
-
-  const rewriteReturns = node => {
-    if (!Array.isArray(node)) return node
-    if (node[0] === 'return' && node.length > 1) {
-      return ['block',
-        ['result', resultType],
-        ['local.set', ret, node[1]],
-        restore(),
-        ['return', ['local.get', ret]],
-        ['unreachable']]
-    }
-    for (let i = 1; i < node.length; i++) node[i] = rewriteReturns(node[i])
-    return node
-  }
-
-  const endsWithReturn = fn.at(-1)?.[0] === 'return' || fn.at(-1)?.[0] === 'return_call'
-  for (let i = bodyStart; i < fn.length; i++) fn[i] = rewriteReturns(fn[i])
-  const newBodyStart = findFuncBodyStart(fn)
-  fn.splice(newBodyStart, 0,
-    ['local', save, 'i32'],
-    ['local', ret, resultType],
-    ['local.set', save, heapGetIR()])
-  if (!endsWithReturn) {
-    const last = fn.pop()
-    fn.push(['local.set', ret, last], restore(), ['local.get', ret])
-  }
-  return true
-}
-
 // === Module compilation ===
 
 const cloneRepMap = map => map ? new Map([...map].map(([k, v]) => [k, { ...v }])) : null
@@ -748,515 +652,6 @@ function emitClosureBody(cb) {
   return fn
 }
 
-/**
- * Phase: build module-init function `__start`.
- *
- * `__start` is the WebAssembly start function: runs once at instantiation, after
- * imports/globals are bound but before any export is called. It threads together
- * everything that must happen before user code observes a ready module:
- *
- *   1. Reset per-function emit state (locals/repByLocal/boxed/stack) — __start is
- *      a fresh function context with no params.
- *   2. analyzeValTypes(ast) so emit sees correct ptrKind on top-level decls.
- *   3. Sub-module init (foreign module bootstrap) emits first — its globals
- *      must be assigned before main-module code reads them.
- *   4. emit(ast) — user top-level statements (let/const, call expressions, …).
- *   5. boxInit — auto-boxing globals (vars with prop assignments lifted to OBJECT).
- *   6. schemaInit — runtime schema-name table for JSON.stringify.
- *   7. strPoolInit — copy passive string-pool segment to heap (shared memory).
- *   8. typeofInit — preallocate typeof-result string globals.
- *
- * Order in the assembled body: strPool → typeof → box → schema → moduleInits → init.
- *
- * Late closures (those compiled during __start emit, e.g. arrows declared at
- * module scope) are flushed via `compilePendingClosures` and prepended to
- * `sec.funcs` so closure indices stay stable across the table.
- */
-function buildStartFn(ast, sec, closureFuncs, compilePendingClosures) {
-  ctx.func.locals = new Map()
-  ctx.func.repByLocal = null
-  ctx.func.boxed = new Map()
-  ctx.func.stack = []
-  ctx.func.current = { params: [], results: [] }
-  analyzeValTypes(ast)
-  const normalizeIR = ir => !ir?.length ? [] : Array.isArray(ir[0]) ? ir : [ir]
-
-  const moduleInits = []
-  if (ctx.module.moduleInits) {
-    for (const mi of ctx.module.moduleInits) {
-      analyzeValTypes(mi)
-      moduleInits.push(...normalizeIR(emit(mi)))
-    }
-  }
-  const init = emit(ast)
-
-  const boxInit = []
-  if (ctx.schema.autoBox) {
-    const bt = `${T}box`
-    ctx.func.locals.set(bt, 'i32')
-    for (const [name, { schemaId, schema }] of ctx.schema.autoBox) {
-      inc('__alloc_hdr', '__mkptr')
-      boxInit.push(
-        ['local.set', `$${bt}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
-        ['f64.store', ['local.get', `$${bt}`],
-          ctx.func.names.has(name) ? ['f64.const', 0] : ['global.get', `$${name}`]],
-        ...schema.slice(1).map((_, i) =>
-          ['f64.store', ['i32.add', ['local.get', `$${bt}`], ['i32.const', (i + 1) * 8]], ['f64.const', 0]]),
-        ['global.set', `$${name}`, mkPtrIR(PTR.OBJECT, schemaId, ['local.get', `$${bt}`])])
-    }
-  }
-
-  const schemaInit = []
-  // Schema name table is needed by JSON.stringify (legacy), and by __dyn_get's
-  // OBJECT-schema fallback for polymorphic-receiver `.prop` access. Lift the
-  // gate to also populate when any __dyn_get* family helper is included so
-  // polymorphic OBJECT patterns (mismatched-schema `?:`, unknown-schema
-  // params) resolve via runtime aux→sid lookup. Direct dependents of
-  // __dyn_get (set transitively by resolveIncludes() later) are listed
-  // explicitly here because the dep graph hasn't been expanded yet at
-  // start-fn build time.
-  // __jp_obj registers schemas at runtime, so the table must be allocated
-  // (and __schema_next initialized) even with zero compile-time schemas.
-  // __jp pulls __jp_obj transitively via the include-graph but resolveIncludes
-  // runs after buildStartFn, so check the top-level __jp parser as a proxy.
-  const hasJpObj = ctx.core.includes.has('__jp_obj') || ctx.core.includes.has('__jp')
-  const needsSchemaTbl = (ctx.schema.list.length && (
-    ctx.core.includes.has('__stringify') ||
-    ctx.core.includes.has('__dyn_get') ||
-    ctx.core.includes.has('__dyn_get_t') ||
-    ctx.core.includes.has('__dyn_get_any') ||
-    ctx.core.includes.has('__dyn_get_any_t') ||
-    ctx.core.includes.has('__dyn_get_expr') ||
-    ctx.core.includes.has('__dyn_get_expr_t') ||
-    ctx.core.includes.has('__dyn_get_or'))) ||
-    hasJpObj
-  if (needsSchemaTbl) {
-    const nSchemas = ctx.schema.list.length
-    // Reserve trailing slots for runtime-registered schemas (used by JSON.parse
-    // shape caching). __schema_next tracks the first free runtime slot.
-    const runtimeReserve = hasJpObj ? 256 : 0
-    const stbl = `${T}stbl`
-    const sarr = `${T}sarr`
-    ctx.func.locals.set(stbl, 'i32')
-    ctx.func.locals.set(sarr, 'i32')
-    inc('__alloc', '__alloc_hdr', '__mkptr')
-    schemaInit.push(
-      ['local.set', `$${stbl}`, ['call', '$__alloc', ['i32.const', (nSchemas + runtimeReserve) * 8]]],
-      ['global.set', '$__schema_tbl', ['local.get', `$${stbl}`]])
-    if (runtimeReserve) {
-      schemaInit.push(['global.set', '$__schema_next', ['i32.const', nSchemas]])
-    }
-    for (let s = 0; s < nSchemas; s++) {
-      const keys = ctx.schema.list[s]
-      const n = keys.length
-      schemaInit.push(
-        ['local.set', `$${sarr}`, ['call', '$__alloc_hdr', ['i32.const', n], ['i32.const', n], ['i32.const', 8]]])
-      for (let k = 0; k < n; k++)
-        schemaInit.push(
-          ['f64.store', ['i32.add', ['local.get', `$${sarr}`], ['i32.const', k * 8]],
-            emit(['str', String(keys[k])])])
-      schemaInit.push(
-        ['f64.store', ['i32.add', ['local.get', `$${stbl}`], ['i32.const', s * 8]],
-          mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${sarr}`])])
-    }
-  }
-
-  const strPoolInit = []
-  if (ctx.runtime.strPool) {
-    const total = ctx.runtime.strPool.length
-    strPoolInit.push(
-      ['global.set', '$__strBase', ['call', '$__alloc', ['i32.const', total]]],
-      ['memory.init', '$__strPool', ['global.get', '$__strBase'], ['i32.const', 0], ['i32.const', total]],
-      ['data.drop', '$__strPool'],
-    )
-  }
-
-  const typeofInit = []
-  if (ctx.runtime.typeofStrs) {
-    for (const s of ctx.runtime.typeofStrs)
-      typeofInit.push(['global.set', `$__tof_${s}`, emit(['str', s])])
-  }
-  // WASI timer queue needs an init call in __start; JS-host mode delegates
-  // scheduling to the host so no init/loop is needed.
-  const wasiTimers = ctx.features.timers && ctx.transform.host === 'wasi'
-  if (moduleInits.length || init?.length || boxInit.length || schemaInit.length || typeofInit.length || strPoolInit.length || wasiTimers) {
-    const initIR = normalizeIR(init)
-    const startFn = ['func', '$__start']
-    for (const [l, t] of ctx.func.locals) startFn.push(['local', `$${l}`, t])
-    startFn.push(...strPoolInit, ...typeofInit, ...boxInit, ...schemaInit,
-      ...(wasiTimers ? [['call', '$__timer_init']] : []),
-      ...moduleInits, ...initIR,
-      ...(ctx.features.blockingTimers ? [['call', '$__timer_loop']] : []),
-    )
-    sec.start.push(startFn, ['start', '$__start'])
-  }
-
-  const beforeLen = closureFuncs.length
-  compilePendingClosures()
-  if (closureFuncs.length > beforeLen)
-    sec.funcs.unshift(...closureFuncs.slice(beforeLen))
-}
-
-/**
- * Phase: closure-body dedup.
- *
- * Two closures with structurally-equal bodies (same shape after alpha-renaming
- * locals/params) are emitted as a single function — duplicates redirect through
- * the elem table to the canonical name. Closure bodies often share shape because
- * the same inner arrow can be instantiated in many places (e.g. parser combinators).
- *
- * IN:  closureFuncs (the WAT IR list emitted by emitClosureBody),
- *      sec.funcs (already contains closureFuncs + regular funcs),
- *      ctx.closure.table (elem-section names).
- * OUT: sec.funcs filtered to canonical bodies, ctx.closure.table redirected.
- *
- * Runs AFTER all closures (including those compiled during __start emit) are
- * collected so structural duplicates across batches collapse together.
- */
-function dedupClosureBodies(closureFuncs, sec) {
-  if (closureFuncs.length <= 1) return
-  const canonicalize = (fn) => {
-    const localNames = new Set()
-    const collect = (node) => {
-      if (!Array.isArray(node)) return
-      if ((node[0] === 'local' || node[0] === 'param') && typeof node[1] === 'string' && node[1][0] === '$')
-        localNames.add(node[1])
-      for (const c of node) collect(c)
-    }
-    collect(fn)
-    let counter = 0
-    const renameMap = new Map()
-    const walk = node => {
-      if (typeof node === 'string') {
-        if (!localNames.has(node)) return node
-        let r = renameMap.get(node)
-        if (!r) { r = `$_c${counter++}`; renameMap.set(node, r) }
-        return r
-      }
-      if (!Array.isArray(node)) return node
-      return node.map(walk)
-    }
-    return JSON.stringify(['func', ...fn.slice(2).map(walk)])
-  }
-  const hashToName = new Map()
-  const redirect = new Map()
-  const keepSet = new Set()
-  for (const fn of closureFuncs) {
-    const key = canonicalize(fn)
-    const name = fn[1].slice(1)
-    const canonical = hashToName.get(key)
-    if (canonical) redirect.set(name, canonical)
-    else { hashToName.set(key, name); keepSet.add(name) }
-  }
-  if (!redirect.size) return
-  // Remove duplicate declarations BEFORE rewriting references — otherwise redirectRefs
-  // renames the declaration itself and the filter can't find the original name.
-  const kept = sec.funcs.filter(fn => {
-    if (!Array.isArray(fn) || fn[0] !== 'func') return true
-    const name = typeof fn[1] === 'string' && fn[1][0] === '$' ? fn[1].slice(1) : null
-    return !name || !redirect.has(name)
-  })
-  const redirectRefs = node => {
-    if (typeof node === 'string') return node[0] === '$' && redirect.has(node.slice(1)) ? `$${redirect.get(node.slice(1))}` : node
-    if (!Array.isArray(node)) return node
-    for (let i = 0; i < node.length; i++) node[i] = redirectRefs(node[i])
-    return node
-  }
-  for (const fn of kept) redirectRefs(fn)
-  ctx.closure.table = ctx.closure.table.map(n => redirect.get(n) || n)
-  sec.funcs.length = 0
-  sec.funcs.push(...kept)
-}
-
-/**
- * Phase: closure-table finalize + ABI shrink.
- *
- * Two opportunities, both gated on a post-emit scan for `call_indirect`:
- *
- *   1. Drop dead $ftN type / table / elem when the scan finds zero call_indirect
- *      sites (every closure call was direct-dispatched via A3 + capture-boundary
- *      propagation, AND no top-level fn was taken as a value). Closure pointers
- *      still carry funcIdx in their NaN-box aux bits, but those bits become dead
- *      state with no reader.
- *
- *   2. Per-body ABI shrink: with no call_indirect, every closure is direct-only,
- *      so the uniform `(env, argc, a0..a{W-1})` ABI is no longer required.
- *      Each body sheds:
- *        • $__env     when captures.length === 0
- *        • $__argc    when no rest param (defaults check param value, not argc)
- *        • $__a{i}    for i ≥ fixedN when no rest (caller's UNDEF padding is dead)
- *      Rest closures keep all W slots — argc + slot{fixedN..W-1} are how rest packs.
- *      Both `call` and `return_call` (tail call) sites are rewritten in the same walk.
- */
-function finalizeClosureTable(sec) {
-  let indirectUsed = ctx.transform.host === 'wasi'
-  const scan = (n) => {
-    if (!Array.isArray(n) || indirectUsed) return
-    if (n[0] === 'call_indirect') { indirectUsed = true; return }
-    for (const c of n) if (Array.isArray(c)) scan(c)
-  }
-  for (const fn of sec.funcs) { scan(fn); if (indirectUsed) break }
-  if (!indirectUsed) for (const fn of sec.start) scan(fn)
-  // Also scan raw stdlib strings (pullStdlib hasn't run yet, so stdlib funcs aren't in sec.funcs)
-  if (!indirectUsed) for (const s of Object.keys(ctx.core.stdlib)) {
-    if (ctx.core.stdlib[s]?.includes?.('call_indirect')) { indirectUsed = true; break }
-  }
-  // Keep table if call_indirect is used (closures, timer dispatch, etc.)
-  if (indirectUsed) {
-    if (!ctx.closure.table) ctx.closure.table = []
-    sec.table = [['table', ['export', '"__jz_table"'], ctx.closure.table.length, 'funcref']]
-    sec.elem = ctx.closure.table.length ? [['elem', ['i32.const', 0], 'func', ...ctx.closure.table.map(n => `$${n}`)]] : []
-    return
-  }
-  sec.table = []
-  sec.elem = []
-  sec.types = sec.types.filter(t => !(Array.isArray(t) && t[1] === '$ftN'))
-  const W = ctx.closure.width ?? MAX_CLOSURE_ARITY
-  const abiOf = new Map()
-  for (const cb of (ctx.closure.bodies || [])) {
-    const fixedN = cb.params.length - (cb.rest ? 1 : 0)
-    abiOf.set(cb.name, {
-      needEnv: cb.captures.length > 0,
-      needArgc: !!cb.rest,
-      usedSlots: cb.rest ? W : fixedN,
-      rest: !!cb.rest,
-    })
-  }
-  for (const fn of sec.funcs) {
-    if (!Array.isArray(fn) || fn[0] !== 'func') continue
-    const fnName = typeof fn[1] === 'string' && fn[1][0] === '$' ? fn[1].slice(1) : null
-    const abi = abiOf.get(fnName)
-    if (!abi) continue
-    for (let i = fn.length - 1; i >= 0; i--) {
-      const node = fn[i]
-      if (!Array.isArray(node) || node[0] !== 'param') continue
-      const pname = node[1]
-      if (pname === '$__env' && !abi.needEnv) fn.splice(i, 1)
-      else if (pname === '$__argc' && !abi.needArgc) fn.splice(i, 1)
-      else if (typeof pname === 'string' && pname.startsWith('$__a') && !abi.rest) {
-        const idx = parseInt(pname.slice(4), 10)
-        if (Number.isFinite(idx) && idx >= abi.usedSlots) fn.splice(i, 1)
-      }
-    }
-  }
-  const rewriteCalls = (node) => {
-    if (!Array.isArray(node)) return
-    for (const c of node) if (Array.isArray(c)) rewriteCalls(c)
-    if ((node[0] === 'call' || node[0] === 'return_call') && typeof node[1] === 'string') {
-      const callee = node[1].slice(1)
-      const abi = abiOf.get(callee)
-      if (!abi) return
-      const newArgs = []
-      if (abi.needEnv) newArgs.push(node[2])
-      if (abi.needArgc) newArgs.push(node[3])
-      for (let i = 0; i < abi.usedSlots; i++) newArgs.push(node[4 + i])
-      node.splice(2, node.length - 2, ...newArgs)
-    }
-  }
-  for (const fn of sec.funcs) rewriteCalls(fn)
-  for (const fn of sec.start) rewriteCalls(fn)
-}
-
-/**
- * Phase: pull stdlib + memory.
- *
- * Runs AFTER __start is built — emit calls during __start (e.g. typeofStrs,
- * boxInit, schemaInit) trigger `inc()` for any helpers they need, and those
- * additions must be observed before resolveIncludes() expands the dependency
- * closure.
- *
- * Steps:
- *   1. resolveIncludes() — close the include set under stdlib dependencies.
- *   2. Emit memory section ONLY when some included helper uses memory ops
- *      (G optimization: pure scalar programs ship without memory + __heap).
- *      When memory is needed, the allocator (__alloc + __alloc_hdr + __clear)
- *      is force-included since stdlib funcs may call into it.
- *   3. Pull external (host) stdlibs into sec.extStdlib (must precede normal
- *      imports in the module byte order).
- *   4. Pull resolved factory stdlibs (those keyed by feature gates) into
- *      sec.stdlib via parseWat.
- *
- * Also reports any unresolved stdlib name (logged, not thrown — keeps test
- * output readable when a missing helper is the actual bug).
- */
-function pullStdlib(sec) {
-  resolveIncludes()
-
-  const needsMemory = [...ctx.core.includes].some(n => ctx.core.stdlib[n] && MEM_OPS.test(ctx.core.stdlib[n]))
-  if (!needsMemory) ctx.scope.globals.delete('__heap')
-  if (needsMemory && ctx.module.modules.core) {
-    for (const fn of ['__alloc', '__alloc_hdr', '__clear']) if (!ctx.core.includes.has(fn)) ctx.core.includes.add(fn)
-    const pages = ctx.memory.pages || 1
-    if (ctx.memory.shared) sec.imports.push(['import', '"env"', '"memory"', ['memory', pages]])
-    else sec.memory.push(['memory', ['export', '"memory"'], pages])
-    if (ctx.transform.alloc !== false && ctx.core._allocRawFuncs)
-      sec.funcs.push(...ctx.core._allocRawFuncs.map(s => parseWat(s)))
-  }
-
-  const stdlibStr = (name) => {
-    const v = ctx.core.stdlib[name]
-    return typeof v === 'function' ? v() : v
-  }
-  // Track __ext_* names emitted to host imports. The cleanup below deletes them
-  // from ctx.core.includes (moved into sec.extStdlib instead), so any post-compile
-  // audit (e.g. host: 'wasi') needs to read this list rather than the includes set.
-  ctx.core.extImports ??= new Set()
-  for (const name of Object.keys(ctx.core.stdlib)) {
-    if (name.startsWith('__ext_') && ctx.core.includes.has(name)) {
-      const parsed = parseWat(stdlibStr(name))
-      sec.extStdlib.push(parsed[0] === "module" ? parsed[1] : parsed)
-      ctx.core.extImports.add(name)
-      ctx.core.includes.delete(name)
-    }
-  }
-  for (const n of ctx.core.includes) if (!ctx.core.stdlib[n]) console.error("MISSING stdlib:", n)
-  sec.stdlib.push(...[...ctx.core.includes].map(n => parseWat(stdlibStr(n))))
-}
-
-function syncImports(sec) {
-  for (const imp of ctx.module.imports) {
-    if (!sec.imports.some(i => i[1] === imp[1] && i[2] === imp[2])) sec.imports.push(imp)
-  }
-}
-
-/**
- * Phase: whole-module + per-function optimization passes.
- *
- * Order matters and is non-obvious — fixed deliberately:
- *
- *   1. specializeMkptr — replaces `call $__mkptr (T, A, off)` with `$__mkptr_T_A_d`
- *      for known (T, A) pairs (saves ~4 B/site). Must run BEFORE per-function
- *      passes so the new variants exist when fusedRewrite folds calls into them.
- *   2. specializePtrBase — folds `call F (add (global G) const)` to a `_p`
- *      variant (saves ~3 B/site). After specializeMkptr so mkptr variants
- *      ($__mkptr_T_A_d) are visible to it.
- *   3. sortStrPoolByFreq — reorders string-pool entries so hot strings get low
- *      offsets (shrinking i32.const LEB128). Shared-memory only (passive segment).
- *   4. optimizeFunc per fn — hoistPtrType + fusedRewrite + sortLocalsByUse.
- *      Must run after specializeMkptr/specializePtrBase introduce new helpers.
- *   5. hoistConstantPool — repeated f64 literals → mutable globals.
- *      Last because earlier passes might fold/eliminate constants.
- *
- * Also adjusts $__heap base when data segment exceeds 1024 bytes (default
- * heap base) — keeps user code at offset 0 from clobbering the data segment.
- */
-function optimizeModule(sec) {
-  const cfg = ctx.transform.optimize  // null → all on (back-compat for direct compile() callers)
-  if (!cfg || cfg.specializeMkptr !== false)
-    specializeMkptr([...sec.funcs, ...sec.stdlib, ...sec.start], wat => sec.stdlib.push(parseWat(wat)), parseWat)
-  if (!cfg || cfg.specializePtrBase !== false)
-    specializePtrBase([...sec.funcs, ...sec.stdlib, ...sec.start], wat => sec.stdlib.push(parseWat(wat)), parseWat)
-  if (ctx.runtime.strPool && (!cfg || cfg.sortStrPoolByFreq !== false)) {
-    const poolRef = { pool: ctx.runtime.strPool }
-    sortStrPoolByFreq([...sec.funcs, ...sec.stdlib, ...sec.start], poolRef, ctx.runtime.strPoolDedup)
-    ctx.runtime.strPool = poolRef.pool
-  }
-  for (const s of [...sec.funcs, ...sec.stdlib, ...sec.start]) optimizeFunc(s, cfg)
-  if (!cfg || cfg.arenaRewind !== false) {
-    const safeCallees = arenaRewindModule([...sec.funcs, ...sec.stdlib, ...sec.start])
-    // Build name → WAT IR map for user functions
-    const fnByName = new Map()
-    for (const fn of sec.funcs) {
-      if (Array.isArray(fn) && fn[0] === 'func' && typeof fn[1] === 'string')
-        fnByName.set(fn[1], fn)
-    }
-    for (const func of ctx.func.list) {
-      const fn = fnByName.get(`$${func.name}`)
-      if (fn) applyArenaRewind(func, fn, safeCallees)
-    }
-  }
-  if (!cfg || cfg.hoistConstantPool !== false)
-    hoistConstantPool([...sec.funcs, ...sec.stdlib, ...sec.start], (name, wat) => ctx.scope.globals.set(name, wat))
-
-  const dataLen = ctx.runtime.data?.length || 0
-  if (dataLen > 1024 && !ctx.memory.shared) {
-    const heapBase = (dataLen + 7) & ~7
-    ctx.scope.globals.set('__heap', `(global $__heap (mut i32) (i32.const ${heapBase}))`)
-    if (ctx.scope.globals.has('__heap_start'))
-      ctx.scope.globals.set('__heap_start', `(global $__heap_start (mut i32) (i32.const ${heapBase}))`)
-    for (const s of sec.stdlib)
-      if (s[0] === 'func' && s[1] === '$__clear')
-        for (let i = 2; i < s.length; i++)
-          if (Array.isArray(s[i]) && s[i][0] === 'global.set' && Array.isArray(s[i][2]) && s[i][2][0] === 'i32.const')
-            s[i][2][1] = `${heapBase}`
-  }
-}
-
-/**
- * Phase: strip static-data prefix.
- *
- * R: when `__static_str` runtime helper isn't included, the leading prefix of the
- * data segment (the static string-table header) is dead — strip it and shift all
- * pointer offsets in user code, embedded data slots, and constant-folded NaN-box
- * literals down by `prefix` bytes. ATOM/SSO have no offset, so they're unaffected.
- *
- * Patches both runtime-call form (`__mkptr(T, A, off)`) and the constant-folded
- * form (`f64.reinterpret_i64 (i64.const ...)`) when offset >= prefix.
- */
-function stripStaticDataPrefix(sec) {
-  if (!ctx.runtime.staticDataLen || ctx.core.includes.has('__static_str')) return
-  const prefix = ctx.runtime.staticDataLen
-  const SHIFTABLE = new Set([PTR.STRING, PTR.OBJECT, PTR.ARRAY, PTR.HASH, PTR.SET, PTR.MAP, PTR.BUFFER, PTR.TYPED, PTR.CLOSURE])
-  const data = ctx.runtime.data || ''
-  const buf = new Uint8Array(data.length)
-  for (let i = 0; i < data.length; i++) buf[i] = data.charCodeAt(i)
-  const dv = new DataView(buf.buffer)
-  if (ctx.runtime.staticPtrSlots) {
-    for (const slotOff of ctx.runtime.staticPtrSlots) {
-      if (slotOff < prefix) continue
-      const bits = dv.getBigUint64(slotOff, true)
-      if (((bits >> 48n) & 0xFFF8n) !== NAN_PREFIX) continue
-      const ty = Number((bits >> TAG_SHIFT_BIG) & TAG_MASK_BIG)
-      if (!SHIFTABLE.has(ty)) continue
-      // SSO STRING: "offset" holds packed bytes, not a heap address — never shift.
-      if (ty === PTR.STRING && ((bits >> AUX_SHIFT_BIG) & SSO_BIT_BIG)) continue
-      const off = Number(bits & OFFSET_MASK_BIG)
-      if (off < prefix) continue
-      const hi = bits & ~OFFSET_MASK_BIG
-      dv.setBigUint64(slotOff, hi | BigInt(off - prefix), true)
-    }
-  }
-  let s = ''
-  for (let i = prefix; i < buf.length; i++) s += String.fromCharCode(buf[i])
-  ctx.runtime.data = s
-  if (ctx.runtime.staticPtrSlots) ctx.runtime.staticPtrSlots = ctx.runtime.staticPtrSlots
-    .filter(o => o >= prefix).map(o => o - prefix)
-  const shift = (node) => {
-    if (!Array.isArray(node)) return
-    for (let i = 0; i < node.length; i++) {
-      const child = node[i]
-      if (!Array.isArray(child)) continue
-      if (child[0] === 'call' && child[1] === '$__mkptr' &&
-        Array.isArray(child[2]) && SHIFTABLE.has(child[2][1]) &&
-        Array.isArray(child[4]) && child[4][0] === 'i32.const' &&
-        typeof child[4][1] === 'number' && child[4][1] >= prefix) {
-        // SSO STRING: aux carries SSO_BIT, "offset" holds packed bytes — don't shift.
-        const isSsoString = child[2][1] === PTR.STRING &&
-          Array.isArray(child[3]) && child[3][0] === 'i32.const' &&
-          typeof child[3][1] === 'number' && (child[3][1] & LAYOUT.SSO_BIT)
-        if (!isSsoString) child[4][1] -= prefix
-      } else if (child[0] === 'f64.const' &&
-        typeof child[1] === 'string' && child[1].startsWith('nan:0x')) {
-        const bits = BigInt(child[1].slice(4)) | 0x7FF0000000000000n
-        if (((bits >> 48n) & 0xFFF8n) === NAN_PREFIX) {
-          const ty = Number((bits >> TAG_SHIFT_BIG) & TAG_MASK_BIG)
-          if (SHIFTABLE.has(ty) &&
-              !(ty === PTR.STRING && ((bits >> AUX_SHIFT_BIG) & SSO_BIT_BIG))) {
-            const off = Number(bits & OFFSET_MASK_BIG)
-            if (off >= prefix) {
-              const hi = bits & ~OFFSET_MASK_BIG
-              const newBits = hi | BigInt(off - prefix)
-              child[1] = 'nan:0x' + newBits.toString(16).toUpperCase().padStart(16, '0')
-            }
-          }
-        }
-      }
-      shift(child)
-    }
-  }
-  for (const s of [...sec.funcs, ...sec.stdlib, ...sec.start]) shift(s)
-}
-
 /**
  * Compile prepared AST to WASM module IR.
  * @param {import('./prepare.js').ASTNode} ast - Prepared AST
@@ -1394,20 +789,26 @@ export default function compile(ast, profiler) {
   // WASI command-mode entries (`run`, `_start`) must export as () -> ();
   // wasmtime/wasmer reject f64-returning functions under those names.
   // Parametric entries skip this — a CLI invocation has no way to supply args.
+  const wasiCommandExports = new Set()
   if (ctx.transform.host === 'wasi') {
     const WASI_ENTRIES = new Set(['run', '_start'])
-    for (const func of ctx.func.list) {
-      if (!func.exported || !WASI_ENTRIES.has(func.name)) continue
+    for (const [exportName, val] of Object.entries(ctx.func.exports)) {
+      if (!WASI_ENTRIES.has(exportName)) continue
+      const targetName = val === true ? exportName : val
+      if (typeof targetName !== 'string') continue
+      const func = ctx.func.list.find(f => f.name === targetName)
+      if (!func) continue
       if (func.sig.params.length) continue
-      const inner = isBoundaryWrapped(func) ? `$${func.name}$exp` : `$${func.name}`
+      const inner = isBoundaryWrapped(func) ? `$${targetName}$exp` : `$${targetName}`
       for (const f of sec.funcs) {
-        if (f[1] === inner || f[1] === `$${func.name}`) {
+        if (f[1] === inner || f[1] === `$${targetName}`) {
           const expIdx = f.findIndex(n => Array.isArray(n) && n[0] === 'export')
           if (expIdx >= 0) f.splice(expIdx, 1)
         }
       }
-      sec.funcs.push(['func', `$${func.name}$wasi`, ['export', `"${func.name}"`],
+      sec.funcs.push(['func', `$${exportName}$wasi`, ['export', `"${exportName}"`],
         ['drop', ['call', inner]]])
+      wasiCommandExports.add(exportName)
     }
   }
 
@@ -1495,6 +896,7 @@ export default function compile(ast, profiler) {
 
   // Named export aliases: export { name } or export { source as alias }
   for (const [name, val] of Object.entries(ctx.func.exports)) {
+    if (wasiCommandExports.has(name)) continue
     if (val === true) {
       if (ctx.scope.userGlobals?.has(name)) sec.customs.push(['export', `"${name}"`, ['global', `$${name}`]])
       continue