jz 0.5.1 → 0.7.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,38 +121,58 @@ 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
 
-// Decode f64 return value: null/undefined sentinels → JS values, numbers pass through
+// Memory-free decode of an f64 boundary value: numbers pass through, the reserved
+// atoms become null/undefined/false/true, and an SSO string unpacks its ≤4 inline
+// ASCII bytes straight from the NaN payload. These are exactly the value forms a
+// *memoryless* module can carry across the boundary — a heap string/array/object
+// would need linear memory to exist, so it can't reach here. Heap-carrying modules
+// route through `mem.read` instead (which also handles these, via memory).
 const decode = v => {
-  if (v === v) return v  // fast path: non-NaN
+  if (v === v) return v  // fast path: non-NaN number
   _f64[0] = v
+  // STRING (type 4) + SSO bit: content is the low 32 bits, length the low aux bits.
+  if (decodePtrType(_u32[1]) === 4) {
+    const a = decodePtrAux(_u32[1])
+    if (a & LAYOUT.SSO_BIT) {
+      const len = a & 0x7, off = _u32[0]; let s = ''
+      for (let i = 0; i < len; i++) s += String.fromCharCode((off >>> (i * 8)) & 0xFF)
+      return s
+    }
+  }
   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
 }
 
+// Decode a boundary value that arrives as i64 bits (BigInt carrier) into a JS
+// value. Heap-carrying modules go through `mem.read`; a memoryless module's value
+// is a number/atom/SSO string, decodable from the bits alone.
+const readArgBits = (state, big) => {
+  const f = i64ToF64(big)
+  return state.mem ? state.mem.read(f) : decode(f)
+}
+
 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 = {
@@ -206,7 +218,11 @@ export const memory = (src) => {
     // Instance result: { module, instance, exports, extMap }
     const raw = src?.instance?.exports || src?.exports || src
     mem = src?.exports?.memory || raw.memory
-    if (!mem) return null  // pure scalar module — no memory
+    // Memoryless module (SSO strings / atoms / numbers only — no linear memory):
+    // hand back a minimal reader instead of null so callers can still decode its
+    // boundary values from bits. `read`/`wrapVal` cover the value forms that exist
+    // without memory; `scalar` flags the fast path that skips heap marshaling.
+    if (!mem) return { read: decode, wrapVal: coerce, scalar: true }
     wasmExports = { ...raw, memory: mem }
     extMap = src.extMap || null
     mod = src.module || null
@@ -259,8 +275,7 @@ export const memory = (src) => {
   if (_enhanced.has(mem)) {
     mem.schemas = schemas
     if (wasmExports?._alloc) { alloc = wasmExports._alloc; mem.alloc = alloc }
-    if (wasmExports?._clear) mem.reset = wasmExports._clear
-    else if (!mem.reset) mem.reset = jsReset
+    mem.reset = jsReset   // post-init rewind — see the note at the first-enhance path
     if (extMap) mem._extMap = extMap
     return mem
   }
@@ -285,9 +300,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 +322,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 +347,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 +364,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 +374,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 +383,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 +410,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 +433,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 +445,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 +454,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 +484,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)
@@ -482,13 +496,29 @@ export const memory = (src) => {
   }
 
   mem.alloc = alloc
-  mem.reset = wasmExports?._clear || jsReset
+  // Rewind to the JS-captured post-init heap mark, NOT the wasm `_clear` (which
+  // rewinds to the static-data end and would clobber module-global heap values —
+  // a top-level `let o = {…}` — on the first alloc after reset). `jsReset`'s base
+  // is `$__heap` read after instantiation (start ran), i.e. exactly the high-water
+  // mark above all module-init allocations. Both share `$__heap`, so a wasm `_alloc`
+  // and this reset stay consistent. (Shared memory has no `$__heap` global → base
+  // is the fixed start, preserving prior behavior.)
+  mem.reset = 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 +543,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 +561,6 @@ export const wrap = (memSrc, inst) => {
       }
     } catch { /* ignore */ }
   }
-
   const mem = memory(memSrc)
   const lastErrBits = realInst.exports.__jz_last_err_bits
   const decodeThrown = error => {
@@ -550,7 +568,9 @@ export const wrap = (memSrc, inst) => {
     const bits = lastErrBits.value
     _u32[0] = Number(bits & 0xffffffffn)
     _u32[1] = Number((bits >> 32n) & 0xffffffffn)
-    const value = mem ? mem.read(_f64[0]) : _f64[0]
+    // Memoryless module: the thrown value is a number/atom/SSO string — decode it
+    // from bits. (A heap Error/string can only exist when the module has memory.)
+    const value = mem ? mem.read(_f64[0]) : decode(_f64[0])
     if (value instanceof Error) throw value
     const wrapped = new Error(typeof value === 'string' ? value : String(value))
     wrapped.cause = error
@@ -558,118 +578,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) {
+  if (!mem || mem.scalar) {
     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)
         }
@@ -729,7 +683,7 @@ const installDefaultEnvImports = (mod, imports, state) => {
     // across the wasm→JS boundary (see module/console.js header). Reinterpret
     // the BigInt's bits as f64 here so mem.read sees the original NaN-box.
     const write = (valBig, fd, sep) => {
-      const v = state.mem.read(i64ToF64(valBig))
+      const v = readArgBits(state, valBig)
       buf[fd] += String(v)
       if (sep === 32) buf[fd] += ' '
       else if (sep === 10) flush(fd)
@@ -747,15 +701,25 @@ 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))
+      const s = readArgBits(state, valBig)
       return parseFloat(s)
     }
   }
   if (envFns.has('parseInt') && !imports.env.parseInt) {
     imports.env.parseInt = (valBig, radix) => {
-      const s = state.mem.read(i64ToF64(valBig))
+      const s = readArgBits(state, valBig)
       return parseInt(s, radix || undefined)
     }
   }
@@ -811,8 +775,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'] })
@@ -904,7 +868,11 @@ const finishInstantiation = (mod, inst, imports, needsWasi, opts, state) => {
   const enhanced = memory(memSrc)
   state.mem = enhanced
   state.flushPrint?.()
-  return { exports: wrap(memSrc), memory: enhanced, instance: inst, module: mod }
+  // A memoryless module keeps a minimal reader internally (state.mem, for decoding
+  // its SSO/atom boundary values), but the result's `.memory` stays null — the
+  // module genuinely exposes no linear memory. `jz.memory(result)` still hands back
+  // a usable reader on demand.
+  return { exports: wrap(memSrc), memory: enhanced?.scalar ? null : enhanced, instance: inst, module: mod }
 }
 
 /**
@@ -919,24 +887,29 @@ const finishInstantiation = (mod, inst, imports, needsWasi, opts, state) => {
  * @param {object} [opts]  host options: imports, memory, _interp, host-shape flags
  * @returns {{ exports, memory, instance, module }}
  */
+/**
+ * Compile wasm bytes to a `WebAssembly.Module`, preferring native
+ * `wasm:js-string` builtins when the engine honors the option (V8 17+/Safari
+ * 18.4+; older engines throw or ignore it — try-fallback handles both). A
+ * `WebAssembly.Module` passed in is returned as-is. Factor it out so callers
+ * can compile once and instantiate many times without re-validating the bytes
+ * (`instantiate(toModule(wasm))` skips the per-call compile on hot loops).
+ *
+ * @param {Uint8Array|ArrayBuffer|WebAssembly.Module} wasm
+ * @returns {WebAssembly.Module}
+ */
+export const toModule = (wasm) => {
+  if (wasm instanceof WebAssembly.Module) return wasm
+  if (jssProbeNative()) {
+    try { return new WebAssembly.Module(wasm, { builtins: ['js-string'] }) }
+    catch { return new WebAssembly.Module(wasm) }
+  }
+  return new WebAssembly.Module(wasm)
+}
+
 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.
-  let mod
-  if (wasm instanceof WebAssembly.Module) {
-    mod = wasm
-  } else if (jssProbeNative()) {
-    try {
-      mod = new WebAssembly.Module(wasm, { builtins: ['js-string'] })
-    } catch {
-      mod = new WebAssembly.Module(wasm)
-    }
-  } else {
-    mod = new WebAssembly.Module(wasm)
-  }
+  const mod = toModule(wasm)
   const { imports, needsWasi } = buildImports(mod, opts, state)
   const hasImports = Object.keys(imports).some(k => k !== '_setMemory')
   const inst = new WebAssembly.Instance(mod, hasImports ? imports : undefined)

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>