jz 0.5.0 → 0.6.0

package/interop.js

@@ -24,7 +24,13 @@
  * @module jz/interop
  */
 
-import { wasi } from './wasi.js'
+import { wasi, attachTimers } from './wasi.js'
+import { HEAP, encodePtrHi, decodePtrType, decodePtrAux, ATOM, ATOM_HI, LAYOUT } from './layout.js'
+
+// Stateless + reusable — one instance avoids a per-call allocation on the hot
+// string read/write paths (mem.String / mem.read STRING).
+const TEXT_ENC = new TextEncoder()
+const TEXT_DEC = new TextDecoder()
 
 // ── WASI linking ────────────────────────────────────────────────────────────
 
@@ -43,15 +49,12 @@ const envFuncNames = (mod) =>
 // threads must share a pointer cell in linear memory). 8-byte aligned bump on
 // the JS side; wasm `_alloc` takes over if exported.
 
-const HEAP_PTR_ADDR = 1020
-const HEAP_START = 1024
-
 const makeJsAllocator = (mem, heapGlobal) => {
   const dv = () => new DataView(mem.buffer)
-  const getPtr = heapGlobal ? () => heapGlobal.value : () => dv().getInt32(HEAP_PTR_ADDR, true)
-  const setPtr = heapGlobal ? v => { heapGlobal.value = v } : v => dv().setInt32(HEAP_PTR_ADDR, v, true)
+  const getPtr = heapGlobal ? () => heapGlobal.value : () => dv().getInt32(HEAP.PTR_ADDR, true)
+  const setPtr = heapGlobal ? v => { heapGlobal.value = v } : v => dv().setInt32(HEAP.PTR_ADDR, v, true)
   // Rewind target: the global's post-static-init value, else the fixed start.
-  const base = heapGlobal ? heapGlobal.value : HEAP_START
+  const base = heapGlobal ? heapGlobal.value : HEAP.START
   const alloc = (bytes) => {
     const aligned = (getPtr() + 7) & ~7
     const next = aligned + bytes
@@ -66,7 +69,7 @@ const makeJsAllocator = (mem, heapGlobal) => {
   const initHeapPtr = () => {
     if (heapGlobal) return
     const d = dv()
-    if (d.getInt32(HEAP_PTR_ADDR, true) < HEAP_START) d.setInt32(HEAP_PTR_ADDR, HEAP_START, true)
+    if (d.getInt32(HEAP.PTR_ADDR, true) < HEAP.START) d.setInt32(HEAP.PTR_ADDR, HEAP.START, true)
   }
   return { alloc, reset, initHeapPtr }
 }
@@ -101,17 +104,6 @@ const sectionReader = (bytes) => {
   }
 }
 
-const attachTimers = (inst) => {
-  if (!inst.exports.__timer_tick) return
-  const tick = inst.exports.__timer_tick
-  let hadTimers = false
-  const id = setInterval(() => {
-    const remaining = tick()
-    if (remaining > 0) hadTimers = true
-    if (hadTimers && remaining <= 0) clearInterval(id)
-  }, 1)
-}
-
 // ── NaN-box codec ───────────────────────────────────────────────────────────
 
 // NaN-boxing encode/decode — shared 8-byte scratch buffer
@@ -129,15 +121,13 @@ const _bi64 = (() => {
 })()
 export const i64ToF64 = _bi64.i64ToF64
 export const f64ToI64 = _bi64.f64ToI64
+
 // Reserved atoms (type=0, offset=0): aux=1 → null, aux=2 → undefined.
 // Distinct from 0, JS NaN (payload=0), and all pointers.
-_u32[1] = 0x7FF80001; _u32[0] = 0; export const NULL_NAN = _f64[0]
-_u32[1] = 0x7FF80002; _u32[0] = 0; export const UNDEF_NAN = _f64[0]
-// Boxed-boolean atoms (type=0, offset=0): aux=4 → false, aux=5 → true. The
-// low aux bit is the truth value; only exported scalars cross as these — the
-// inner 0/1 number carrier never escapes the wasm boundary.
-_u32[1] = 0x7FF80004; _u32[0] = 0; export const FALSE_NAN = _f64[0]
-_u32[1] = 0x7FF80005; _u32[0] = 0; export const TRUE_NAN = _f64[0]
+_u32[1] = ATOM_HI[ATOM.NULL]; _u32[0] = 0; export const NULL_NAN = _f64[0]
+_u32[1] = ATOM_HI[ATOM.UNDEF]; _u32[0] = 0; export const UNDEF_NAN = _f64[0]
+_u32[1] = ATOM_HI[ATOM.FALSE]; _u32[0] = 0; export const FALSE_NAN = _f64[0]
+_u32[1] = ATOM_HI[ATOM.TRUE]; _u32[0] = 0; export const TRUE_NAN = _f64[0]
 
 // Coerce JS null/undefined → NaN-boxed sentinels for WASM boundary
 export const coerce = v => v === null ? NULL_NAN : v === undefined ? UNDEF_NAN : v
@@ -147,20 +137,20 @@ const decode = v => {
   if (v === v) return v  // fast path: non-NaN
   _f64[0] = v
   if (_u32[0] !== 0) return v
-  if (_u32[1] === 0x7FF80001) return null
-  if (_u32[1] === 0x7FF80002) return undefined
-  if (_u32[1] === 0x7FF80004) return false
-  if (_u32[1] === 0x7FF80005) return true
+  if (_u32[1] === ATOM_HI[ATOM.NULL]) return null
+  if (_u32[1] === ATOM_HI[ATOM.UNDEF]) return undefined
+  if (_u32[1] === ATOM_HI[ATOM.FALSE]) return false
+  if (_u32[1] === ATOM_HI[ATOM.TRUE]) return true
   return v
 }
 
 export const ptr = (type, aux, offset) => {
-  _u32[1] = (0x7FF80000 | ((type & 0xF) << 15) | (aux & 0x7FFF)) >>> 0
+  _u32[1] = encodePtrHi(type, aux)
   _u32[0] = offset >>> 0; return _f64[0]
 }
 export const offset = (p) => { _f64[0] = p; return _u32[0] }
-export const type = (p) => { _f64[0] = p; return (_u32[1] >>> 15) & 0xF }
-export const aux = (p) => { _f64[0] = p; return _u32[1] & 0x7FFF }
+export const type = (p) => { _f64[0] = p; return decodePtrType(_u32[1]) }
+export const aux = (p) => { _f64[0] = p; return decodePtrAux(_u32[1]) }
 
 // Typed element metadata: [elemId, byteStride, DataView getter, DataView setter]
 const ELEMS = {
@@ -285,9 +275,9 @@ export const memory = (src) => {
     if (str.length <= 4 && /^[\x00-\x7f]*$/.test(str)) {
       let packed = 0
       for (let i = 0; i < str.length; i++) packed |= str.charCodeAt(i) << (i * 8)
-      return ptr(4, 0x4000 | str.length, packed)  // STRING + SSO_BIT
+      return ptr(4, LAYOUT.SSO_BIT | str.length, packed)  // STRING + SSO_BIT
     }
-    const enc = new TextEncoder().encode(str)
+    const enc = TEXT_ENC.encode(str)
     const n = enc.length, raw = alloc(4 + n), m = dv()
     m.setInt32(raw, n, true)
     const off = raw + 4
@@ -307,23 +297,22 @@ export const memory = (src) => {
   mem.wrapVal = function(v) {
     if (v === null || v === undefined) return coerce(v)
     if (typeof v === 'number' || typeof v === 'boolean') return Number(v)
-    if (typeof v === 'string') return this.String(v)
-    // BigInt as a data value crosses the boundary as a decimal-string. wasm-side
-    // numeric parsers accept string form. Direct i64 function args go through this
-    // path too; the call wrappers below detect BigInt before adaptArgs reinterprets.
-    if (typeof v === 'bigint') return this.String(v.toString())
-    if (Array.isArray(v)) return this.Array(v)
-    if (v instanceof ArrayBuffer) return this.Buffer(v)
-    if (v instanceof DataView) return this.Buffer(v.buffer)
+    if (typeof v === 'string') return mem.String(v)
+    // BigInt as a data value crosses the boundary as a decimal-string; wasm-side
+    // numeric parsers accept string form.
+    if (typeof v === 'bigint') return mem.String(v.toString())
+    if (Array.isArray(v)) return mem.Array(v)
+    if (v instanceof ArrayBuffer) return mem.Buffer(v)
+    if (v instanceof DataView) return mem.Buffer(v.buffer)
     const typedName = v?.constructor?.name
-    if (typedName && ELEMS[typedName]) return this[typedName](v)
-    if (typeof v === 'object' || typeof v === 'function') return this.External(v)
+    if (typedName && ELEMS[typedName]) return mem[typedName](v)
+    if (typeof v === 'object' || typeof v === 'function') return mem.External(v)
     return UNDEF_NAN
   }
 
   mem.External = function(obj) {
     if (obj === null || obj === undefined) return coerce(obj)
-    const map = this._extMap
+    const map = mem._extMap
     if (!map) return UNDEF_NAN
     let id = map.indexOf(obj)
     if (id === -1) { id = map.length; map.push(obj) }
@@ -333,14 +322,14 @@ export const memory = (src) => {
   mem.Object = function(obj) {
     const objKeys = Object.keys(obj)
     const key = objKeys.join(',')
-    const schemas = this.schemas
+    const schemas = mem.schemas
     let sid = schemas.findIndex(s => s.join(',') === key)
     if (sid === -1) {
       const matches = schemas.reduce((a, s, i) =>
         (s.length === objKeys.length && objKeys.every(k => s.includes(k)) ? a.concat(i) : a), [])
       if (matches.length === 1) sid = matches[0]
       else if (matches.length > 1) throw Error(`Ambiguous schema for {${key}} — pass keys in schema order`)
-      else if (this._extMap) return this.External(obj)
+      else if (mem._extMap) return mem.External(obj)
       else throw Error(`No schema for {${key}}`)
     }
     const schema = schemas[sid], n = schema.length, raw = alloc(n * 8)
@@ -350,8 +339,8 @@ export const memory = (src) => {
     for (let i = 0; i < n; i++) {
       let v = obj[schema[i]]
       if (v === null || v === undefined) v = coerce(v)
-      else if (typeof v === 'string') v = this.String(v)
-      else if (Array.isArray(v)) v = this.Array(v)
+      else if (typeof v === 'string') v = mem.String(v)
+      else if (Array.isArray(v)) v = mem.Array(v)
       wrapped[i] = f64ToI64(v)
     }
     const dst = new BigInt64Array(mem.buffer, raw, n)
@@ -360,7 +349,7 @@ export const memory = (src) => {
   }
 
   mem.read = function(p) {
-    if (Array.isArray(p)) return p.map(v => this.read(v))  // multi-value tuple
+    if (Array.isArray(p)) return p.map(v => mem.read(v))  // multi-value tuple
     if (p === p) return p  // regular number passthrough (NaN fails ===)
     const t = type(p), a = aux(p), off = offset(p)
     if (t === 0 && off === 0) {
@@ -369,13 +358,13 @@ export const memory = (src) => {
       if (a === 4) return false
       if (a === 5) return true
     }
-    if (t === 11 && this._extMap) return this._extMap[off]
+    if (t === 11 && mem._extMap) return mem._extMap[off]
     if (t === 1) {  // ARRAY
       let m = dv(), aOff = off
       // Follow forwarding pointers (cap === -1 means array was reallocated)
       while (m.getInt32(aOff - 4, true) === -1) aOff = m.getInt32(aOff - 8, true)
       const len = m.getInt32(aOff - 8, true), out = new Array(len)
-      for (let i = 0; i < len; i++) out[i] = this.read(m.getFloat64(aOff + i * 8, true))
+      for (let i = 0; i < len; i++) out[i] = mem.read(m.getFloat64(aOff + i * 8, true))
       return out
     }
     if (t === 3) {  // TYPED
@@ -396,21 +385,21 @@ export const memory = (src) => {
       new Uint8Array(out).set(new Uint8Array(mem.buffer, off, byteLen))
       return out
     }
-    if (t === 4) {  // STRING (aux bit 0x4000 = SSO inline, else heap)
+    if (t === 4) {  // STRING (aux SSO_BIT = inline, else heap)
       const a2 = aux(p)
-      if (a2 & 0x4000) {
+      if (a2 & LAYOUT.SSO_BIT) {
         const len = a2 & 0x7; let s = ''
         for (let i = 0; i < len; i++) s += String.fromCharCode((off >>> (i * 8)) & 0xFF)
         return s
       }
       const len = dv().getInt32(off - 4, true)
-      return new TextDecoder().decode(new Uint8Array(mem.buffer, off, len))
+      return TEXT_DEC.decode(new Uint8Array(mem.buffer, off, len))
     }
     if (t === 6) {  // OBJECT
-      const m = dv(), sid = aux(p), keys = this.schemas[sid]
+      const m = dv(), sid = aux(p), keys = mem.schemas[sid]
       if (!keys) return p
       const obj = {}
-      for (let i = 0; i < keys.length; i++) obj[keys[i]] = this.read(m.getFloat64(off + i * 8, true))
+      for (let i = 0; i < keys.length; i++) obj[keys[i]] = mem.read(m.getFloat64(off + i * 8, true))
       return obj
     }
     if (t === 7) {  // HASH
@@ -419,8 +408,8 @@ export const memory = (src) => {
       for (let i = 0, found = 0; i < cap && found < size; i++) {
         const hash = m.getFloat64(off + i * 24, true)
         if (hash !== 0) {
-          const key = this.read(m.getFloat64(off + i * 24 + 8, true))
-          obj[key] = this.read(m.getFloat64(off + i * 24 + 16, true))
+          const key = mem.read(m.getFloat64(off + i * 24 + 8, true))
+          obj[key] = mem.read(m.getFloat64(off + i * 24 + 16, true))
           found++
         }
       }
@@ -431,7 +420,7 @@ export const memory = (src) => {
       const set = new Set()
       for (let i = 0; i < cap && set.size < size; i++) {
         const hash = m.getFloat64(off + i * 16, true)
-        if (hash !== 0) set.add(this.read(m.getFloat64(off + i * 16 + 8, true)))
+        if (hash !== 0) set.add(mem.read(m.getFloat64(off + i * 16 + 8, true)))
       }
       return set
     }
@@ -440,7 +429,7 @@ export const memory = (src) => {
       const map = new Map()
       for (let i = 0; i < cap && map.size < size; i++) {
         const hash = m.getFloat64(off + i * 24, true)
-        if (hash !== 0) map.set(this.read(m.getFloat64(off + i * 24 + 8, true)), this.read(m.getFloat64(off + i * 24 + 16, true)))
+        if (hash !== 0) map.set(mem.read(m.getFloat64(off + i * 24 + 8, true)), mem.read(m.getFloat64(off + i * 24 + 16, true)))
       }
       return map
     }
@@ -470,7 +459,7 @@ export const memory = (src) => {
         for (let i = 0; i < data.length; i++) m[setter](off + i * stride, data[i], true)
       }
     } else if (t === 6) {
-      const schema = this.schemas[aux(p)]
+      const schema = mem.schemas[aux(p)]
       if (!schema) throw Error(`write: unknown schema`)
       for (const k of Object.keys(data)) {
         const i = schema.indexOf(k)
@@ -485,10 +474,19 @@ export const memory = (src) => {
   mem.reset = wasmExports?._clear || jsReset
 
   // TypedArray constructors: memory.Float64Array(data), etc.
+  // Bulk-copy path: when input is a TypedArray whose element type matches
+  // the target (same stride), use .set() for a fast memcpy instead of
+  // per-element DataView writes. Falls back to DataView for mismatched types.
+  const TA = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array]
   for (const [name, [elemId, stride, , setter]] of Object.entries(ELEMS)) {
     mem[name] = (data) => {
-      const n = data.length, bytes = n * stride, off = hdr(bytes, bytes, bytes), m = dv()
-      for (let i = 0; i < n; i++) m[setter](off + i * stride, data[i], true)
+      const n = data.length, bytes = n * stride, off = hdr(bytes, bytes, bytes)
+      if (stride >= 2 && TA[elemId] && data instanceof TA[elemId]) {
+        new TA[elemId](mem.buffer, off, n).set(data)
+      } else {
+        const m = dv()
+        for (let i = 0; i < n; i++) m[setter](off + i * stride, data[i], true)
+      }
       return ptr(3, elemId, off)
     }
   }
@@ -513,19 +511,8 @@ export const wrap = (memSrc, inst) => {
         restFuncs.set(typeof entry === 'string' ? entry : entry.name, typeof entry === 'string' ? 0 : entry.fixed)
     } catch (e) { /* ignore */ }
   }
-  // i64-ABI exports: boundary-wrapped funcs whose NaN-boxed pointer params/
-  // result ride i64 to dodge V8's NaN canonicalization. Map: name → { p, r }
-  // with p = bit mask of i64 params, r = 1 iff result is i64. JS side
-  // reinterprets f64↔BigInt only at those positions (see
-  // synthesizeBoundaryWrappers).
-  const i64Exp = new Map(), EMPTY_SET = new Set()
-  const i64Bytes = customSection(mod, 'jz:i64exp')
-  if (i64Bytes) {
-    try { for (const e of JSON.parse(td.decode(i64Bytes))) i64Exp.set(e.name, { p: new Set(e.p), r: e.r }) }
-    catch { /* ignore */ }
-  }
   // externref-param exports: positions where the wasm side takes an externref
-  // (e.g. jsstring boundary opt-in). JS values at these positions pass through
+  // (jsstring carrier — js-host only). JS values at these positions pass through
   // unchanged — no `mem.wrapVal` (would NaN-box into f64, defeating the point).
   // `def` (optional) maps idx → default-string for jsstring params whose
   // default substitution happens JS-side (the wasm side never sees null).
@@ -542,7 +529,6 @@ export const wrap = (memSrc, inst) => {
       }
     } catch { /* ignore */ }
   }
-
   const mem = memory(memSrc)
   const lastErrBits = realInst.exports.__jz_last_err_bits
   const decodeThrown = error => {
@@ -558,118 +544,52 @@ export const wrap = (memSrc, inst) => {
     throw wrapped
   }
   const exports = {}
-  // Per-position carrier swap: f64 stays Number, i64 positions reinterpret to
-  // BigInt before the call and back to Number after. p is a Set of i64 param
-  // indices; r = result is i64. Numeric (f64) positions pass through unchanged.
-  const adaptArgs = (a, p) => p.size === 0 ? a : a.map((x, i) => p.has(i) ? f64ToI64(x) : x)
-  const adaptRet = (ret, r) => r ? i64ToF64(ret) : ret
-  // Externref positions skip mem.wrapVal — the raw JS value (string, object,
-  // …) flows through as externref. mem.wrapVal would NaN-box it.
-  const wrapArg = (ext, i, x) => ext?.has(i) ? x : mem.wrapVal(x)
-
-  // Arity-specialized wrapper: rest-spread + .map() + .apply() costs ~85ns/call
-  // on hot loops (mandelbrot benchmark: 51ms wrapped vs 35ms direct over 200K
-  // calls). Generating positional `function(a0, a1, ...)` via Function lets V8
-  // fully inline the WASM call. Falls back to the spread-form wrapper if the
-  // Function constructor is unavailable (CSP) or arity is unusually large.
-  // `ext` is a Set of externref param positions — those slots skip wrap/coerce
-  // and pass the JS value directly (jsstring carrier: JS string → externref).
-  // `ext.def` (optional Map idx→string) carries jsstring-literal defaults that
-  // are substituted JS-side when the caller passes `undefined`.
-  const makeFastWrapper = (fn, len, p, r, decode_, wrap_, ext) => {
-    const params = [], wrapped = []
-    const defs = ext?.def
-    const defArgs = [], defNames = []
-    for (let i = 0; i < len; i++) {
-      const a = `a${i}`
-      params.push(a)
-      if (ext?.has(i)) {
-        if (defs?.has(i)) {
-          const dn = `def${i}`
-          defNames.push(dn); defArgs.push(defs.get(i))
-          wrapped.push(`(${a} === undefined ? ${dn} : ${a})`)
-        } else {
-          wrapped.push(a)
-        }
-        continue
-      }
-      const w = wrap_ ? `wrap_(${a})` : `coerce(${a})`
-      wrapped.push(p.has(i) ? `f64ToI64(${w})` : w)
-    }
-    const callExpr = `fn(${wrapped.join(',')})`
-    const retExpr = r ? `i64ToF64(${callExpr})` : callExpr
-    const body = `return function(${params.join(',')}) {\n` +
-      `  try { return decode_(${retExpr}) } catch (e) { decodeThrown(e) }\n` +
-      `}`
-    return new Function('fn', 'wrap_', 'coerce', 'decode_', 'f64ToI64', 'i64ToF64', 'decodeThrown', ...defNames, body)(
-      fn, wrap_, coerce, decode_, f64ToI64, i64ToF64, decodeThrown, ...defArgs)
-  }
+  // Wrap one positional arg. Externref slots (jsstring carrier) pass the JS
+  // value straight through — `mem.wrapVal` would NaN-box it — substituting a
+  // jsstring literal default for a missing arg. Every other slot marshals via
+  // `box`: `coerce` for pure-scalar modules, `mem.wrapVal` for heap modules.
+  // Quiet-NaN ABI: every export value is f64, so there is no per-position i64
+  // carrier — args flow straight to the wasm call, results straight to decode/read.
+  const wrapArgAt = (ext, i, x, box) =>
+    ext?.has(i) ? (x === undefined && ext.def?.has(i) ? ext.def.get(i) : x) : box(x)
 
   // Pure scalar module (no memory): pass f64 values directly, no marshaling
   if (!mem) {
     for (const [name, fn] of Object.entries(realInst.exports)) {
       if (typeof fn !== 'function') { exports[name] = fn; continue }
-      const sig = i64Exp.get(name)
-      const p = sig?.p || EMPTY_SET, r = sig?.r || 0
       const ext = extExp.get(name)
       const len = fn.length
-      try {
-        exports[name] = makeFastWrapper(fn, len, p, r, decode, null, ext)
-        continue
-      } catch { /* CSP fallback */ }
       exports[name] = (...args) => {
         while (args.length < len) args.push(undefined)
         try {
-          const wasmArgs = adaptArgs(args.map((x, i) => {
-            if (!ext?.has(i)) return coerce(x)
-            return x === undefined && ext.def?.has(i) ? ext.def.get(i) : x
-          }), p)
-          return decode(adaptRet(fn(...wasmArgs), r))
+          return decode(fn(...args.map((x, i) => wrapArgAt(ext, i, x, coerce))))
         } catch (e) { decodeThrown(e) }
       }
     }
     return exports
   }
   const memWrapVal = mem.wrapVal.bind(mem)
-  const memRead = mem.read.bind(mem)
   for (const [name, fn] of Object.entries(realInst.exports)) {
     if (restFuncs.has(name) && typeof fn === 'function') {
       const fixed = restFuncs.get(name)
-      const sig = i64Exp.get(name)
-      const p = sig?.p || EMPTY_SET, r = sig?.r || 0
       const ext = extExp.get(name)
       exports[name] = (...args) => {
-        const a = args.slice(0, fixed).map((x, i) => {
-          if (!ext?.has(i)) return mem.wrapVal(x)
-          return x === undefined && ext.def?.has(i) ? ext.def.get(i) : x
-        })
+        const a = args.slice(0, fixed).map((x, i) => wrapArgAt(ext, i, x, memWrapVal))
         while (a.length < fixed) a.push(UNDEF_NAN)
         a.push(mem.Array(args.slice(fixed)))
         try {
-          const ret = fn.apply(null, adaptArgs(a, p))
-          return mem.read(adaptRet(ret, r))
+          return mem.read(fn.apply(null, a))
         } catch (error) {
           decodeThrown(error)
         }
       }
     } else if (typeof fn === 'function') {
-      const sig = i64Exp.get(name)
-      const p = sig?.p || EMPTY_SET, r = sig?.r || 0
       const ext = extExp.get(name)
       const len = fn.length
-      try {
-        exports[name] = makeFastWrapper(fn, len, p, r, memRead, memWrapVal, ext)
-        continue
-      } catch { /* CSP fallback */ }
       exports[name] = (...args) => {
         while (args.length < len) args.push(undefined)
         try {
-          const boxed = args.map((x, i) => {
-            if (!ext?.has(i)) return mem.wrapVal(x)
-            return x === undefined && ext.def?.has(i) ? ext.def.get(i) : x
-          })
-          const ret = fn.apply(null, adaptArgs(boxed, p))
-          return mem.read(adaptRet(ret, r))
+          return mem.read(fn.apply(null, args.map((x, i) => wrapArgAt(ext, i, x, memWrapVal))))
         } catch (error) {
           decodeThrown(error)
         }
@@ -747,6 +667,16 @@ const installDefaultEnvImports = (mod, imports, state) => {
     imports.env.now = (clock) =>
       clock === 1 ? (typeof performance !== 'undefined' ? performance.now() : Date.now()) : Date.now()
   }
+  // One i32 of entropy to seed Math.random — only present when compiled with
+  // { randomSeed: true }. Prefers crypto; falls back to Math.random.
+  if (envFns.has('rngSeed') && !imports.env.rngSeed) {
+    imports.env.rngSeed = () => {
+      const a = new Uint32Array(1)
+      if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(a)
+      else a[0] = (Math.random() * 0x100000000) >>> 0
+      return a[0] | 0
+    }
+  }
   if (envFns.has('parseFloat') && !imports.env.parseFloat) {
     imports.env.parseFloat = (valBig) => {
       const s = state.mem.read(i64ToF64(valBig))
@@ -811,8 +741,8 @@ const jssProbeNative = () => {
       0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00,        // header
       0x01, 0x06, 0x01, 0x60, 0x01, 0x6f, 0x01, 0x7f,        // type: (externref)→i32
       0x02, 0x18, 0x01,                                       // import section
-      0x0f, ...new TextEncoder().encode('wasm:js-string'),    // mod name
-      0x06, ...new TextEncoder().encode('length'),            // name
+      0x0f, ...TEXT_ENC.encode('wasm:js-string'),             // mod name
+      0x06, ...TEXT_ENC.encode('length'),                     // name
       0x00, 0x00,                                             // kind=func, type=0
     ])
     const mod = new WebAssembly.Module(bytes, { builtins: ['js-string'] })
@@ -921,7 +851,6 @@ const finishInstantiation = (mod, inst, imports, needsWasi, opts, state) => {
  */
 export const instantiate = (wasm, opts = {}) => {
   const state = prepareInterop(opts)
-  opts.extMap = state.extMap
   // Prefer native `wasm:js-string` builtins when the engine honors the option.
   // The option is silently accepted by V8 17+/Safari 18.4+; older engines that
   // don't recognize it either throw or ignore it — try-fallback handles both.

package/jz.svg

@@ -0,0 +1,5 @@
+<svg width="630" height="630" viewBox="0 0 630 630" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M630 0H0V630H630V0Z" fill="black"/>
+<path d="M165.65 526.474L213.863 497.296C223.164 513.788 231.625 527.74 251.92 527.74C271.374 527.74 283.639 520.13 283.639 490.53V289.23H342.843V491.367C342.843 552.688 306.899 580.599 254.458 580.599C207.096 580.599 179.605 556.07 165.65 526.469" fill="white"/>
+<path d="M412.075 316.04H534.138L409.808 550.902H546.138" stroke="white" stroke-width="54" stroke-linecap="square"/>
+</svg>

package/jzify/arguments.js

@@ -0,0 +1,97 @@
+/**
+ * `arguments` object + destructuring-param lowering for function→arrow conversion.
+ * @module jzify/arguments
+ */
+
+import { paramList } from '../src/ast.js'
+import { isDestructurePat, prependDecls } from './hoist-vars.js'
+
+function usesArguments(node) {
+  if (node === 'arguments') return true
+  if (!Array.isArray(node)) return false
+  if (node[0] === 'function') return false
+  // Literal node `[, value]` (op === null) — node[1] is a string/number VALUE, not an
+  // identifier. A string literal `'arguments'` must not read as the arguments object.
+  if (node[0] == null) return false
+  if (node[0] === '.' || node[0] === '?.') return usesArguments(node[1])
+  if (node[0] === ':') return usesArguments(node[2])
+  for (let i = 1; i < node.length; i++) if (usesArguments(node[i])) return true
+  return false
+}
+
+function bindsArguments(body) {
+  const isArgDecl = s => Array.isArray(s) && (s[0] === 'var' || s[0] === 'let' || s[0] === 'const') &&
+    s.slice(1).some(d => d === 'arguments' || (Array.isArray(d) && d[0] === '=' && d[1] === 'arguments'))
+  let n = body
+  if (Array.isArray(n) && n[0] === '{}') n = n[1]
+  if (Array.isArray(n) && n[0] === ';') return n.slice(1).some(isArgDecl)
+  return isArgDecl(n)
+}
+
+function renameArguments(node, to) {
+  if (node === 'arguments') return to
+  if (!Array.isArray(node)) return node
+  if (node[0] === 'function') return node
+  // Literal node `[, value]` — node[1] is a value, not an identifier; leave untouched
+  // so a string literal `'arguments'` survives the rename.
+  if (node[0] == null) return node
+  if (node[0] === '.' || node[0] === '?.')
+    return [node[0], renameArguments(node[1], to), node[2]]
+  if (node[0] === ':')
+    return [node[0], node[1], renameArguments(node[2], to)]
+  return node.map(n => renameArguments(n, to))
+}
+
+function prependParamDecls(decl, body) {
+  if (Array.isArray(body) && body[0] === '{}') {
+    const inner = body[1]
+    if (Array.isArray(inner) && inner[0] === ';') return ['{}', [';', decl, ...inner.slice(1)]]
+    if (inner == null) return ['{}', decl]
+    return ['{}', [';', decl, inner]]
+  }
+  if (Array.isArray(body) && (body[0] === ';' || body[0] === 'return')) return [';', decl, body]
+  return ['{}', [';', decl, ['return', body]]]
+}
+
+/** @param {ReturnType<import('./names.js').createNames>} names */
+export function createArgumentsLowering(names) {
+  function lowerArguments(params, body) {
+    if (bindsArguments(body)) body = renameArguments(body, names.arg())
+    const paramsNeedLowering = paramList(params).some(isDestructurePat)
+    const usesArgsObj = usesArguments(params) || usesArguments(body)
+    if (!paramsNeedLowering && !usesArgsObj) return [params, body]
+    const name = names.arg()
+    const decls = []
+    for (const [idx, param] of paramList(params).entries()) {
+      if (Array.isArray(param) && param[0] === '...') {
+        decls.push(['=', param[1], ['()', ['.', name, 'slice'], [null, idx]]])
+        continue
+      }
+      if (Array.isArray(param) && param[0] === '=') {
+        decls.push(['=', param[1], ['??', ['[]', name, [null, idx]], renameArguments(param[2], name)]])
+        continue
+      }
+      decls.push(['=', param, ['[]', name, [null, idx]]])
+    }
+    const renamed = usesArgsObj ? renameArguments(body, name) : body
+    return [['()', ['...', name]], decls.length ? prependParamDecls(['let', ...decls], renamed) : renamed]
+  }
+
+  let transformRef = null
+  const transformPattern = (node) => {
+    const transform = transformRef
+    if (node == null || !Array.isArray(node)) return node
+    const op = node[0]
+    if (op === '=') return ['=', transformPattern(node[1]), transform(node[2])]
+    if (op === ':') return [':', transform(node[1]), transformPattern(node[2])]
+    if (op === '...') return ['...', transformPattern(node[1])]
+    if (op === '[]' || op === '{}' || op === ',') return [op, ...node.slice(1).map(transformPattern)]
+    return transform(node)
+  }
+
+  return {
+    lowerArguments,
+    transformPattern,
+    bindTransform(fn) { transformRef = fn },
+  }
+}