jz 0.9.0 → 0.9.2

package/interop.js

@@ -203,6 +203,9 @@ const ELEMS = {
   Uint32Array: [5, 4, 'getUint32', 'setUint32'],
   Float32Array: [6, 4, 'getFloat32', 'setFloat32'],
   Float64Array: [7, 8, 'getFloat64', 'setFloat64'],
+  // flag-carrying kinds: elemId = base code | flag (32 = f16, 64 = clamped)
+  Float16Array: [35, 2, 'getFloat16', 'setFloat16'],
+  Uint8ClampedArray: [65, 1, 'getUint8', 'setUint8'],
 }
 // Pre-built lookup by element ID (avoids Object.values on each access)
 const ELEM_BY_ID = Object.values(ELEMS)
@@ -400,9 +403,12 @@ export const memory = (src) => {
     const entries = Object.entries(obj)
     let cap = 8
     while (entries.length * 4 >= cap * 3) cap <<= 1   // stay under the 75% grow trigger
-    const off = hdr(entries.length, cap, cap * 24)
+    // cap × (24-B entry + 4-B probe hash lane) — collection.js's exact layout;
+    // the lane (after the entries) is what wasm probes walk
+    const off = hdr(entries.length, cap, cap * 28)
     // Stage every slot as i64 bits (empty = 0) — same NaN-canonicalization dodge as mem.Array.
     const staged = new BigInt64Array(cap * 3)
+    const lane = new Int32Array(cap)
     entries.forEach(([k, v], seq) => {
       const keyBox = mem.String(k)
       const h = jzStrHash(keyBox)
@@ -411,9 +417,11 @@ export const memory = (src) => {
       staged[idx * 3] = (BigInt(seq) << 32n) | BigInt(h >>> 0)
       staged[idx * 3 + 1] = bits(keyBox)
       staged[idx * 3 + 2] = bits(mem.wrapVal(v))
+      lane[idx] = h | 0
     })
     const dst = new BigInt64Array(mem.buffer, off, cap * 3)
     dst.set(staged)
+    new Int32Array(mem.buffer, off + cap * 24, cap).set(lane)
     return ptr(7, 0, off)
   }
 
@@ -474,7 +482,10 @@ export const memory = (src) => {
     if (t === 3) {  // TYPED
       const elem = a & 7
       const [, stride] = ELEM_BY_ID[elem]
-      const Ctor = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][elem]
+      const Ctor = (a & 32)
+        ? (globalThis.Float16Array ?? (() => { throw new Error('decoding a Float16Array result needs a host with Float16Array (Node ≥ 24 / modern browsers)') })())
+        : (a & 64) ? Uint8ClampedArray
+        : [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array][elem]
       if (a & 8) {
         const byteLen = m.getInt32(off, true), dataOff = m.getInt32(off + 4, true)
         return new Ctor(mem.buffer, dataOff, byteLen / stride)
@@ -574,6 +585,8 @@ export const memory = (src) => {
   // 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]
+  TA[65] = Uint8ClampedArray
+  if (globalThis.Float16Array) TA[35] = globalThis.Float16Array
   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)
@@ -844,13 +857,24 @@ const prepareInterop = (opts) => {
   // in JS) — see module/collection.js header for rationale. f64 returns are
   // wrapped back to BigInt so the wasm side reinterprets a non-canonicalized
   // bit pattern.
-  opts._interp.__ext_prop = (objBig, propBig) => {
+  // A dynamic member op can reach the host with a receiver that is NOT an
+  // external handle (extMap[0] is null — e.g. a builtin's placeholder value, or
+  // a number that inference couldn't type whose method jz doesn't implement).
+  // Without the guard that surfaces as a bare host TypeError ("Cannot read
+  // properties of null") — a mystery. Name the actual failure instead.
+  const extRecv = (objBig, prop, what) => {
     const obj = state.extMap[offset(objBig)]
+    if (obj == null) throw new Error(`'${prop}' — jz dispatched this ${what} to the host, but the receiver is not a host object (an unsupported builtin method, or a receiver type jz couldn't resolve)`)
+    return obj
+  }
+  opts._interp.__ext_prop = (objBig, propBig) => {
     const prop = state.mem.read(propBig)
+    const obj = extRecv(objBig, prop, 'property read')
     return bits(state.mem.wrapVal(typeof obj[prop] === 'function' ? obj[prop].bind(obj) : obj[prop]))
   }
   opts._interp.__ext_has = (objBig, propBig) => {
-    return (state.mem.read(propBig) in state.extMap[offset(objBig)]) ? 1 : 0
+    const prop = state.mem.read(propBig)
+    return (prop in extRecv(objBig, prop, 'membership test')) ? 1 : 0
   }
   opts._interp.__ext_set = (objBig, propBig, valBig) => {
     let v = state.mem.read(valBig)
@@ -867,13 +891,16 @@ const prepareInterop = (opts) => {
     // same-ctor copy — exactly `new Ctor(view)` with no manual size/offset
     // bookkeeping — and a no-op for every other decoded value shape.
     if (ArrayBuffer.isView(v)) v = v.slice()
-    state.extMap[offset(objBig)][state.mem.read(propBig)] = v
+    const prop = state.mem.read(propBig)
+    extRecv(objBig, prop, 'property write')[prop] = v
     return 1
   }
   opts._interp.__ext_call = (objBig, propBig, argsBig) => {
-    const obj = state.extMap[offset(objBig)]
     const prop = state.mem.read(propBig)
+    const obj = extRecv(objBig, prop, 'method call')
     const args = state.mem.read(argsBig)
+    if (typeof obj[prop] !== 'function')
+      throw new Error(`'${prop}' is not a function on this host ${obj?.constructor?.name ?? 'object'}`)
     return hostRet(state, obj[prop].apply(obj, args))
   }
   return state
@@ -935,6 +962,19 @@ const installDefaultEnvImports = (mod, imports, state) => {
       return a[0] | 0
     }
   }
+  // Byte-fill entropy for crypto.getRandomValues/randomUUID (module/crypto.js).
+  // Fills wasm linear memory directly; the view is created per call — never
+  // cached — so a Memory.grow between calls can't leave a detached view.
+  if (envFns.has('random') && !imports.env.random) {
+    imports.env.random = (off, len) => {
+      const view = new Uint8Array(state.mem.buffer, off, len)
+      if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(view)
+      else for (let i = 0; i < len; i++) view[i] = (Math.random() * 256) >>> 0
+    }
+  }
+  if (envFns.has('hardwareConcurrency') && !imports.env.hardwareConcurrency) {
+    imports.env.hardwareConcurrency = () => globalThis.navigator?.hardwareConcurrency ?? 1
+  }
   if (envFns.has('parseFloat') && !imports.env.parseFloat) {
     imports.env.parseFloat = (valBig) => {
       const s = readArgBits(state, valBig)
@@ -975,6 +1015,31 @@ const installDefaultEnvImports = (mod, imports, state) => {
       return 0
     }
   }
+  // requestAnimationFrame wiring: real rAF where the host has one; a 16 ms
+  // timer elsewhere (Node) so frame-driven modules still run — the callback
+  // receives a real timestamp either way via __invoke_closure1.
+  if (envFns.has('requestAnimationFrame') || envFns.has('cancelAnimationFrame')) {
+    const cancel = new Map()
+    let nextId = 1
+    if (envFns.has('requestAnimationFrame') && !imports.env.requestAnimationFrame) imports.env.requestAnimationFrame = (cbBig) => {
+      const id = nextId++
+      const fire = (t) => { cancel.delete(id); state.invoke1?.(cbBig, t); state.afterTick?.() }
+      const raf = globalThis.requestAnimationFrame
+      if (typeof raf === 'function') {
+        const h = raf(fire)
+        cancel.set(id, () => globalThis.cancelAnimationFrame?.(h))
+      } else {
+        const h = setTimeout(() => fire(typeof performance !== 'undefined' ? performance.now() : Date.now()), 16)
+        cancel.set(id, () => clearTimeout(h))
+      }
+      return id
+    }
+    if (envFns.has('cancelAnimationFrame') && !imports.env.cancelAnimationFrame) imports.env.cancelAnimationFrame = (id) => {
+      const c = cancel.get(id)
+      if (c) { c(); cancel.delete(id) }
+      return 0
+    }
+  }
 }
 
 // JS-side polyfills for `wasm:js-string` builtins. Used when the engine does
@@ -1085,6 +1150,8 @@ const finishInstantiation = (mod, inst, imports, needsWasi, opts, state) => {
 
   // Trampoline used by env.setTimeout/clearTimeout to fire scheduled closures.
   state.invoke = inst.exports.__invoke_closure || null
+  // One-arg variant — env.requestAnimationFrame passes the frame timestamp.
+  state.invoke1 = inst.exports.__invoke_closure1 || null
 
   // Drive WASM timer queue via JS scheduling (non-blocking, no-op if absent).
   attachTimers(inst)

package/jzify/index.js

@@ -10,6 +10,7 @@
 import { JZIFY_CLASS_ERRORS as JC } from '../src/op-policy.js'
 import { parse } from '../src/parse.js'
 import { createAsyncLowering, ASYNC_RUNTIME, ASYNC_GEN_RUNTIME } from './async.js'
+import { USP_RUNTIME } from './webrt.js'
 import { createNames } from './names.js'
 import { foldStaticExportHelpers, foldStaticBundlerHelpers, canonicalizeObjectIdioms } from './bundler.js'
 import { createSwitchLowering, normalizeCaseBody } from './switch.js'
@@ -47,7 +48,9 @@ const iterProto = { on: false }
 const genErr = (msg) => { throw new Error('jzify: ' + msg) }
 const { lowerGenerator, desugarForOfGenerator, desugarForOfProtocol, unwindChain, fuseTerminal, fusedLoop, isTerminal } = createGeneratorLowering({ transform, err: genErr, generatorNames, genTemp: (t) => names.genTemp(t), iterProto })
 const { lowerAsync, lowerAsyncGen, noteAsync, asyncUsed, agenUsed, resetAsync } = createAsyncLowering({ genTemp: (t) => names.genTemp(t), err: genErr })
-bindGenerators({ lowerGenerator, desugarForOfGenerator, desugarForOfProtocol, lowerAsync, lowerAsyncGen, noteAsync, generatorNames, iterProto, unwindChain, fuseTerminal, fusedLoop, isTerminal })
+// Web-runtime splice flags (URLSearchParams, …) — reset per transform run.
+const webrt = { usp: false }
+bindGenerators({ lowerGenerator, desugarForOfGenerator, desugarForOfProtocol, lowerAsync, lowerAsyncGen, noteAsync, generatorNames, iterProto, unwindChain, fuseTerminal, fusedLoop, isTerminal, webrt })
 transformSwitch = createSwitchLowering(transform, names)
 
 // Spread normalization for iterator values — injected only when a spread site
@@ -140,6 +143,7 @@ export default function jzify(ast) {
   if (Array.isArray(ast) && ast[0] === ';') ast = [';', ...foldPseudoClassical(ast.slice(1))]
   resetAsync()
   iterProto.drain = false
+  webrt.usp = false
   let out = transformScope(ast)
   const prepend = (src) => {
     // runtimes ride the same well-known-symbol canonicalization as user code
@@ -159,6 +163,8 @@ export default function jzify(ast) {
   // [Symbol.iterator]() mints (__it_from) → splice the decorated-iterator
   // factory. Programs without value-position helpers never take this shape.
   if (iterProto.helpersUsed || iterProto.fromUsed) prepend(ITER_HELPERS_RUNTIME)
+  // URLSearchParams sites → splice the jz-source implementation (webrt.js).
+  if (webrt.usp) prepend(USP_RUNTIME)
   // async generators → splice the tagged-yield driver (before the promise
   // runtime prepend so it lands AFTER it in module order — it calls __p_*).
   if (agenUsed()) prepend(ASYNC_GEN_RUNTIME)

package/jzify/transform.js

@@ -9,8 +9,8 @@ import { isDestructurePat } from './hoist-vars.js'
 
 const ERROR_INSTANCEOF = new Set(['Error', 'TypeError', 'SyntaxError', 'RangeError', 'ReferenceError', 'URIError', 'EvalError'])
 
-const TYPED_ARRAYS = new Set(['Float64Array','Float32Array','Int32Array','Uint32Array',
-  'Int16Array','Uint16Array','Int8Array','Uint8Array',
+const TYPED_ARRAYS = new Set(['Float64Array','Float32Array','Float16Array','Int32Array','Uint32Array',
+  'Int16Array','Uint16Array','Int8Array','Uint8Array','Uint8ClampedArray',
   'ArrayBuffer','BigInt64Array','BigUint64Array','DataView'])
 
 const isProto = n => Array.isArray(n) && n[0] === '.' && Array.isArray(n[1]) && n[1][0] === '.' && n[1][2] === 'prototype'
@@ -263,6 +263,19 @@ export function createTransform(opts) {
           _gen.noteAsync()
           return ['()', P_STATIC[callee[2]], ...rest.map(a => a == null ? a : transform(a))]
         }
+        // queueMicrotask(fn) IS the runtime's job queue: push onto __mt, drained
+        // at the same host boundaries promise jobs are. Evaluates to undefined
+        // per spec (push's return length is discarded by the comma).
+        if (callee === 'queueMicrotask' && rest.length) {
+          _gen.noteAsync()
+          return [',', ['()', ['.', '__mt', 'push'], ...rest.map(a => a == null ? a : transform(a))], 'undefined']
+        }
+      }
+      // URLSearchParams rides a spliced jz-source runtime (jzify/webrt.js);
+      // `new URLSearchParams(x)` unwraps to this same call via the `new` handler.
+      if (callee === 'URLSearchParams' && _gen?.webrt) {
+        _gen.webrt.usp = true
+        return ['()', '__usp_new', ...rest.map(a => a == null ? a : transform(a))]
       }
       // Terminal iterator helper (toArray/reduce/forEach/some/every/find) on a
       // chain rooted at a known generator call → fused IIFE loop.
@@ -448,6 +461,12 @@ export function createTransform(opts) {
       // form, and `new URL(rel, import.meta.url)` lowers to a static href string there.
       // User classes (lowered to factory arrows by jzify) become plain calls below.
       if (typeof name === 'string' && (TYPED_ARRAYS.has(name) || name === 'Array' || name === 'RegExp' || name === 'URL')) return ['new', transform(ctor), ...cargs.map(transform)]
+      // paren-less `new URLSearchParams` (ctor arrives as a bare string —
+      // the call-node form unwraps through the '()' handler below)
+      if (name === 'URLSearchParams' && typeof ctor === 'string' && _gen?.webrt) {
+        _gen.webrt.usp = true
+        return ['()', '__usp_new']
+      }
       if (Array.isArray(ctor) && ctor[0] === '()') return transform(ctor)
       return ['()', transform(ctor), ...(cargs.length ? cargs.map(transform) : [null])]
     },

package/jzify/webrt.js

@@ -0,0 +1,145 @@
+/**
+ * Web-platform runtime pieces, as readable jz source — spliced ahead of user
+ * code by jzify when used (the ASYNC_RUNTIME pattern; pay-per-use, programs
+ * without them compile byte-identically).
+ *
+ * URLSearchParams: `new URLSearchParams(init)` canonicalizes to __usp_new —
+ * a fixed-shape object with closure methods over parallel key/value arrays
+ * (the promise-runtime object shape). WHATWG semantics: forgiving percent
+ * decode ('+' is space, malformed escapes pass through as literals — never a
+ * throw), application/x-www-form-urlencoded escaping on toString (space→'+',
+ * only [A-Za-z0-9*-._] bare, UTF-8 bytes %XX'd — jz's byte-strings make that
+ * exact). Divergences (documented): keys()/values()/entries() return arrays
+ * (iterable with for-of, not live iterators), sort() compares UTF-8 bytes
+ * (spec: UTF-16 units — differs only past ASCII), and the object is not
+ * itself iterable — iterate `.entries()`.
+ *
+ * @module jzify/webrt
+ */
+
+export const USP_RUNTIME = `
+let __usp_hex = (c) => c >= 48 && c <= 57 ? c - 48 : c >= 65 && c <= 70 ? c - 55 : c >= 97 && c <= 102 ? c - 87 : -1
+let __usp_lt = (a, b) => {
+  let n = a.length < b.length ? a.length : b.length
+  for (let i = 0; i < n; i++) {
+    let x = a.charCodeAt(i)
+    let y = b.charCodeAt(i)
+    if (x !== y) return x < y
+  }
+  return a.length < b.length
+}
+let __usp_dec = (s) => {
+  let n = s.length
+  let buf = new Uint8Array(n)
+  let j = 0
+  for (let i = 0; i < n; i++) {
+    let c = s.charCodeAt(i)
+    if (c === 43) { buf[j] = 32; j = j + 1 }
+    else if (c === 37 && i + 2 < n) {
+      let h = __usp_hex(s.charCodeAt(i + 1))
+      let l = __usp_hex(s.charCodeAt(i + 2))
+      if (h >= 0 && l >= 0) { buf[j] = h * 16 + l; j = j + 1; i = i + 2 }
+      else { buf[j] = c; j = j + 1 }
+    } else { buf[j] = c; j = j + 1 }
+  }
+  return new TextDecoder().decode(buf.slice(0, j))
+}
+let __usp_esc = (s) => {
+  let out = ''
+  let n = s.length
+  for (let i = 0; i < n; i++) {
+    let c = s.charCodeAt(i)
+    if (c === 32) out = out + '+'
+    else if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 42 || c === 45 || c === 46 || c === 95) out = out + s[i]
+    else {
+      let h = c >> 4
+      let l = c & 15
+      out = out + '%' + String.fromCharCode(h < 10 ? 48 + h : 55 + h) + String.fromCharCode(l < 10 ? 48 + l : 55 + l)
+    }
+  }
+  return out
+}
+let __usp_new = (init) => {
+  let ks = []
+  let vs = []
+  let self = { __usp: 1, size: 0, get: undefined, getAll: undefined, has: undefined, append: undefined, set: undefined, delete: undefined, forEach: undefined, keys: undefined, values: undefined, entries: undefined, sort: undefined, toString: undefined }
+  let find = (k) => { for (let i = 0; i < ks.length; i++) { if (ks[i] === k) return i } return -1 }
+  self.get = (k) => { let i = find(String(k)); return i < 0 ? null : vs[i] }
+  self.getAll = (k) => { let key = String(k); let out = []; for (let i = 0; i < ks.length; i++) { if (ks[i] === key) out.push(vs[i]) } return out }
+  self.has = (k, v) => { let key = String(k); for (let i = 0; i < ks.length; i++) { if (ks[i] === key && (v === undefined || vs[i] === String(v))) return true } return false }
+  self.append = (k, v) => { ks.push(String(k)); vs.push(String(v)); self.size = ks.length; return undefined }
+  self.set = (k, v) => {
+    let key = String(k)
+    let i = find(key)
+    if (i < 0) { self.append(key, v); return undefined }
+    vs[i] = String(v)
+    let w = i + 1
+    for (let r = i + 1; r < ks.length; r++) {
+      if (ks[r] !== key) { ks[w] = ks[r]; vs[w] = vs[r]; w = w + 1 }
+    }
+    ks.splice(w)
+    vs.splice(w)
+    self.size = ks.length
+    return undefined
+  }
+  self.delete = (k, v) => {
+    let key = String(k)
+    let w = 0
+    for (let r = 0; r < ks.length; r++) {
+      if (!(ks[r] === key && (v === undefined || vs[r] === String(v)))) { ks[w] = ks[r]; vs[w] = vs[r]; w = w + 1 }
+    }
+    ks.splice(w)
+    vs.splice(w)
+    self.size = ks.length
+    return undefined
+  }
+  self.forEach = (fn) => { for (let i = 0; i < ks.length; i++) fn(vs[i], ks[i], self); return undefined }
+  self.keys = () => ks.slice()
+  self.values = () => vs.slice()
+  self.entries = () => { let out = []; for (let i = 0; i < ks.length; i++) out.push([ks[i], vs[i]]); return out }
+  self.sort = () => {
+    for (let i = 1; i < ks.length; i++) {
+      let k = ks[i]
+      let v = vs[i]
+      let j = i - 1
+      while (j >= 0 && __usp_lt(k, ks[j])) { ks[j + 1] = ks[j]; vs[j + 1] = vs[j]; j = j - 1 }
+      ks[j + 1] = k
+      vs[j + 1] = v
+    }
+    return undefined
+  }
+  self.toString = () => {
+    let out = ''
+    for (let i = 0; i < ks.length; i++) {
+      if (i > 0) out = out + '&'
+      out = out + __usp_esc(ks[i]) + '=' + __usp_esc(vs[i])
+    }
+    return out
+  }
+  if (init != null) {
+    if (typeof init === 'string') {
+      let s = init
+      if (s[0] === '?') s = s.slice(1)
+      if (s.length > 0) {
+        let parts = s.split('&')
+        for (let pi = 0; pi < parts.length; pi++) {
+          let part = parts[pi]
+          if (part.length > 0) {
+            let eq = part.indexOf('=')
+            if (eq < 0) self.append(__usp_dec(part), '')
+            else self.append(__usp_dec(part.slice(0, eq)), __usp_dec(part.slice(eq + 1)))
+          }
+        }
+      }
+    } else if (Array.isArray(init)) {
+      for (let pi = 0; pi < init.length; pi++) { let pair = init[pi]; self.append(pair[0], pair[1]) }
+    } else if (init.__usp === 1) {
+      init.forEach((v, k) => self.append(k, v))
+    } else {
+      let es = Object.entries(init)
+      for (let ei = 0; ei < es.length; ei++) { let e = es[ei]; self.append(e[0], e[1]) }
+    }
+  }
+  return self
+}
+`

package/layout.js

@@ -80,14 +80,20 @@ export const ptrBits = (type, aux = 0, offset = 0) =>
 // `module/typedarray` stdlib.
 // =============================================================================
 
-/** Base element-type codes for PTR.TYPED aux (0–7). BigInt ctors share 7 + TYPED_ELEM_BIGINT_FLAG. */
+/** Base element-type codes for PTR.TYPED aux (0–7). Flag-sharing kinds ride a
+ *  base code (which fixes stride/shift) plus a discriminator bit: BigInt ctors
+ *  share 7 + BIGINT_FLAG, Float16Array shares 3 (u16 storage) + F16_FLAG,
+ *  Uint8ClampedArray shares 1 (u8 storage) + CLAMPED_FLAG. */
 export const TYPED_ELEM_CODE = {
   Int8Array: 0, Uint8Array: 1, Int16Array: 2, Uint16Array: 3,
   Int32Array: 4, Uint32Array: 5, Float32Array: 6, Float64Array: 7,
   BigInt64Array: 7, BigUint64Array: 7,
+  Float16Array: 3, Uint8ClampedArray: 1,
 }
 export const TYPED_ELEM_VIEW_FLAG = 8
 export const TYPED_ELEM_BIGINT_FLAG = 16
+export const TYPED_ELEM_F16_FLAG = 32
+export const TYPED_ELEM_CLAMPED_FLAG = 64
 
 export const TYPED_ELEM_NAMES = ['Int8Array', 'Uint8Array', 'Int16Array', 'Uint16Array',
   'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array']
@@ -97,7 +103,9 @@ export function encodeTypedElemAux(name, isView = false) {
   const et = TYPED_ELEM_CODE[name]
   if (et == null) return null
   return et | (isView ? TYPED_ELEM_VIEW_FLAG : 0) |
-    (name === 'BigInt64Array' || name === 'BigUint64Array' ? TYPED_ELEM_BIGINT_FLAG : 0)
+    (name === 'BigInt64Array' || name === 'BigUint64Array' ? TYPED_ELEM_BIGINT_FLAG : 0) |
+    (name === 'Float16Array' ? TYPED_ELEM_F16_FLAG : 0) |
+    (name === 'Uint8ClampedArray' ? TYPED_ELEM_CLAMPED_FLAG : 0)
 }
 
 /** Encode a `typedElemCtor` string ('new.Int32Array' | 'new.Int32Array.view') to the 4-bit
@@ -116,7 +124,9 @@ export function typedElemAux(ctor) {
 export function ctorFromElemAux(aux) {
   if (aux == null) return null
   const isView = (aux & 8) !== 0
-  const name = (aux & 16) !== 0 ? 'BigInt64Array' : TYPED_ELEM_NAMES[aux & 7]
+  const name = (aux & TYPED_ELEM_F16_FLAG) !== 0 ? 'Float16Array'
+    : (aux & TYPED_ELEM_CLAMPED_FLAG) !== 0 ? 'Uint8ClampedArray'
+    : (aux & 16) !== 0 ? 'BigInt64Array' : TYPED_ELEM_NAMES[aux & 7]
   if (!name) return null
   return isView ? `new.${name}.view` : `new.${name}`
 }

package/module/array.js

@@ -13,7 +13,7 @@ import { inBoundsArrIdx } from '../src/type.js'
 import { emit, spread, deps, idx as emitIndex } from '../src/bridge.js'
 import { valTypeOf } from '../src/kind.js'
 import { extractParams, classifyParam, ASSIGN_OPS, refsName, REFS_IN_EXPR } from '../src/ast.js'
-import { staticPropertyKey, staticObjectProps, inlineArraySid, staticIndexKey, intLiteralValue } from '../src/static.js'
+import { staticPropertyKey, staticObjectProps, inlineArraySid, staticIndexKey, intLiteralValue, structLiteralFields } from '../src/static.js'
 import { VAL, lookupValType, lookupNotString, updateRep } from '../src/reps.js'
 import { structInline } from '../src/abi/index.js'
 import { ctx, inc, err, warnDeopt, PTR, LAYOUT, followForwardingWat } from '../src/ctx.js'
@@ -62,25 +62,6 @@ function hoistArrayValue(arr) {
 
 const arrayLenFromPtr = ptr => ['i32.load', ['i32.sub', ['local.get', `$${ptr}`], ['i32.const', 8]]]
 
-/** K schema-ordered field-value AST nodes of an object literal `{S}` for a
- *  structInline `.push({S})`, or null if `lit` is not a plain static-key `{}`
- *  literal carrying exactly schema `sid`'s fields. Mapped by name into schema
- *  order so push sites with differing key order flatten to the same cell run. */
-function structLiteralFields(lit, sid) {
-  if (!Array.isArray(lit) || lit[0] !== '{}') return null
-  const parsed = staticObjectProps(lit.slice(1))
-  const schema = ctx.schema.list[sid]
-  if (!parsed || parsed.names.length !== schema.length) return null
-  const byName = new Map()
-  for (let i = 0; i < parsed.names.length; i++) byName.set(parsed.names[i], parsed.values[i])
-  const out = []
-  for (const name of schema) {
-    if (!byName.has(name)) return null
-    out.push(byName.get(name))
-  }
-  return out
-}
-
 // Pure-expression check: no statements, binders, control flow, or assignments.
 // Inlining is only safe for these — anything else needs the full closure machinery.
 const NOT_PURE_OPS = new Set([
@@ -854,11 +835,16 @@ export default (ctx) => {
       if (inlSid != null) {
         const baseI32 = tempI32('ab')
         const K = ctx.schema.list[inlSid].length
-        const cell = typed(structInline(K).ops.elemAddr(
+        const packed = ctx.schema.inlineCellI32?.has(inlSid)
+        const cell = typed(structInline(K, packed).ops.elemAddr(
           ['local.tee', `$${baseI32}`, arrBase()],
           vi), 'i32')
         cell.ptrKind = VAL.OBJECT
         cell.ptrAux = inlSid
+        // Packed i32 cells: slot access through this node (and through cursor
+        // locals bound to it — readVar re-derives via inlineCellCursors) must
+        // pick the packedI32 ops.
+        if (packed) cell.cellI32 = true
         return cell
       }
       // Known-ARRAY → __arr_idx (single forwarding follow + inline bounds check),
@@ -1010,14 +996,18 @@ export default (ctx) => {
     // statement-position hint now so a dropped `xs.push(v)` can skip computing
     // the JS return length while still performing the mutation/writeback.
     const void_ = ctx.func._expect === 'void'
-    // structInline Array<S>: `.push({S})` writes the K schema fields as K
-    // consecutive f64 cells. Flatten the struct literal into K schema-ordered
+    // structInline Array<S>: `.push({S})` writes the K schema fields as
+    // consecutive cells. Flatten the struct literal into K schema-ordered
     // field-value nodes and fall through to the general multi-value store path
-    // — `len`/`cap` count physical cells, so `__arr_grow_known` and the cell
-    // loop are reused untouched; `.push` then returns the logical element count
-    // (`len / K`). K=1 stays a single value → the `__arr_push1` fast path.
+    // — `len`/`cap` count physical 8-byte cells, so `__arr_grow_known` and the
+    // cell loop are reused untouched; `.push` then returns the logical element
+    // count (`len / cellsPerElem`). K=1 stays a single value → the
+    // `__arr_push1` fast path. Packed schemas (inlineCellI32) store K raw i32
+    // fields into ⌈K/2⌉ cells — the store loop below branches per layout.
     const inlSid = inlineArraySid(arr)
     const inlK = inlSid != null ? ctx.schema.list[inlSid].length : 0
+    const inlPacked = inlSid != null && ctx.schema.inlineCellI32?.has(inlSid)
+    const inlCpe = inlSid != null ? structInline(inlK, inlPacked).cpe : 1
     if (inlSid != null) {
       const flat = []
       for (const v of vals) {
@@ -1027,6 +1017,8 @@ export default (ctx) => {
       }
       vals = flat
     }
+    // Physical cells this push appends (grow target + len increment basis).
+    const pushCells = inlPacked ? inlCpe * (vals.length / inlK) : vals.length
     // Out-of-line fast path: single value, named known-ARRAY receiver. One call +
     // var update instead of ~30 inlined instructions — the dominant size cost of
     // push-heavy code (e.g. watr's WASM emitter).
@@ -1071,31 +1063,45 @@ export default (ctx) => {
         ['if',
           ['i32.lt_s',
             ['i32.load', ['i32.sub', ['local.get', `$${pushBase}`], ['i32.const', 4]]],
-            ['i32.add', ['local.get', `$${len}`], ['i32.const', vals.length]]],
+            ['i32.add', ['local.get', `$${len}`], ['i32.const', pushCells]]],
           ['then',
             ['local.set', `$${t}`, ['call', `$${grow}`, ['i64.reinterpret_f64', ['local.get', `$${t}`]],
-              ['i32.add', ['local.get', `$${len}`], ['i32.const', vals.length]]]],
+              ['i32.add', ['local.get', `$${len}`], ['i32.const', pushCells]]]],
             ['local.set', `$${pushBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]]],
       )
     } else {
       body.push(
         ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
-        // Grow if needed: ensure cap >= len + vals.length
+        // Grow if needed: ensure cap >= len + pushCells
         ['local.set', `$${t}`, ['call', `$${grow}`, ['i64.reinterpret_f64', ['local.get', `$${t}`]],
-          ['i32.add', ['local.get', `$${len}`], ['i32.const', vals.length]]]],
+          ['i32.add', ['local.get', `$${len}`], ['i32.const', pushCells]]]],
         ['local.set', `$${pushBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
       )
     }
 
-    // Store each value and increment len
-    for (const val of vals) {
-      const vv = carrierF64(val, emit(val))
-      body.push(
-        ['f64.store',
-          ['i32.add', ['local.get', `$${pushBase}`], ['i32.shl', ['local.get', `$${len}`], ['i32.const', 3]]],
-          vv],
-        ['local.set', `$${len}`, ['i32.add', ['local.get', `$${len}`], ['i32.const', 1]]]
-      )
+    if (inlPacked) {
+      // Packed i32 cells: per element, K raw i32 stores at `base + len*8 + j*4`
+      // (schema order — structLiteralFields already ordered the flatten), then
+      // len advances by ⌈K/2⌉ physical cells. Values are exact by the
+      // slotI32Certain census (packing precondition).
+      for (let e = 0; e < vals.length; e += inlK) {
+        for (let j = 0; j < inlK; j++) {
+          const off = ['i32.add', ['local.get', `$${pushBase}`], ['i32.shl', ['local.get', `$${len}`], ['i32.const', 3]]]
+          body.push(['i32.store', j === 0 ? off : ['i32.add', off, ['i32.const', j * 4]], asI32(emit(vals[e + j]))])
+        }
+        body.push(['local.set', `$${len}`, ['i32.add', ['local.get', `$${len}`], ['i32.const', inlCpe]]])
+      }
+    } else {
+      // Store each value and increment len
+      for (const val of vals) {
+        const vv = carrierF64(val, emit(val))
+        body.push(
+          ['f64.store',
+            ['i32.add', ['local.get', `$${pushBase}`], ['i32.shl', ['local.get', `$${len}`], ['i32.const', 3]]],
+            vv],
+          ['local.set', `$${len}`, ['i32.add', ['local.get', `$${len}`], ['i32.const', 1]]]
+        )
+      }
     }
 
     // Update length header (write directly via the offset we already hold —
@@ -1113,9 +1119,10 @@ export default (ctx) => {
         body.push(['local.set', `$${arr}`, ['local.get', `$${t}`]])
     }
     // structInline: `len` counts physical cells — `.push` returns the JS array
-    // length, i.e. the logical element count `len / K`.
-    body.push(['f64.convert_i32_s', inlK > 1
-      ? ['i32.div_s', ['local.get', `$${len}`], ['i32.const', inlK]]
+    // length, i.e. the logical element count `len / cellsPerElem`.
+    const lenDiv = inlPacked ? inlCpe : inlK
+    body.push(['f64.convert_i32_s', lenDiv > 1
+      ? ['i32.div_s', ['local.get', `$${len}`], ['i32.const', lenDiv]]
       : ['local.get', `$${len}`]])
 
     return typed(['block', ['result', 'f64'], ...body], 'f64')