jz 0.3.1 → 0.5.0

package/module/object.js

@@ -7,10 +7,11 @@
  * @module object
  */
 
-import { typed, asF64, asI64, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr, elemStore } from '../src/ir.js'
+import { typed, asF64, asI64, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr, elemLoad, elemStore } from '../src/ir.js'
 import { emit } from '../src/emit.js'
 import { valTypeOf, lookupValType, VAL, repOf, updateRep, shapeOf } from '../src/analyze.js'
 import { ctx, err, inc, PTR, LAYOUT } from '../src/ctx.js'
+import { includeModule } from '../src/autoload.js'
 
 
 export default (ctx) => {
@@ -30,9 +31,12 @@ export default (ctx) => {
       // schema-slot writes to offsets >= 8 land out-of-bounds.
       const target = takeLiteralTarget()
       const merged = target ? ctx.schema.resolve(target) : null
-      const schemaId = merged ? ctx.schema.idOf(target) : 0
-      const cap = merged ? Math.max(1, merged.length) : 1
-      return mkPtrIR(PTR.OBJECT, schemaId, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', cap], ['i32.const', 8]])
+      // Register the empty schema so schemaId always indexes a real schema.list
+      // entry — __json_obj and dyn-get load keys via $__schema_tbl[sid] and would
+      // crash on an unregistered id 0 (table left uninitialized when list empty).
+      const schemaId = merged ? ctx.schema.idOf(target) : ctx.schema.register([])
+      const cap = ctx.abi.object.ops.allocSlots(merged ? merged.length : 0)
+      return mkPtrIR(PTR.OBJECT, schemaId, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', cap]])
     }
 
     // Flatten comma-grouped props: [',', p1, p2] → [p1, p2]
@@ -63,7 +67,7 @@ export default (ctx) => {
     // R: Static data segment for objects of pure-literal property values (own-memory only).
     // Even with shadow needed, we can skip alloc + N stores; just feed literal values to __dyn_set.
     const shadow = needsDynShadow(target)
-    if (values.length >= 2 && !ctx.memory.shared) {
+    if (values.length >= 2 && values.length === schema.length && !ctx.memory.shared) {
       const emitted = values.map(emit)
       // asF64 folds i32.const → f64.const so int-literal values also qualify.
       const slots = emitted.map(v => extractF64Bits(asF64(v)))
@@ -82,16 +86,16 @@ export default (ctx) => {
     }
 
     const body = [
-      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(schema.length)]]],
     ]
     for (let i = 0; i < values.length; i++)
-      body.push(['f64.store', slotAddr(t, i), asF64(emit(values[i]))])
+      body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], i, asF64(emit(values[i]))))
     body.push(['local.set', `$${ptr}`, mkPtrIR(PTR.OBJECT, schemaId, ['local.get', `$${t}`])])
     if (shadow) {
       inc('__dyn_set')
       for (let i = 0; i < schema.length; i++)
         body.push(['drop', ['call', '$__dyn_set', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], asI64(emit(['str', String(schema[i])])),
-          ['i64.load', slotAddr(t, i)]]])
+          ctx.abi.object.ops.loadBits(['local.get', `$${t}`], i)]])
     }
     body.push(['local.get', `$${ptr}`])
 
@@ -100,14 +104,82 @@ export default (ctx) => {
 
   // === Object static methods ===
 
+  ctx.core.emit['Object.freeze'] = (obj) => asF64(emit(obj))
+
+  // Object.isExtensible / isSealed / isFrozen.
+  // jz fixes an object's schema at construction: a `{…}` literal can
+  // neither grow nor lose keys, so an OBJECT value is non-extensible and
+  // sealed; its slots stay writable, so it is not frozen. Arrays, maps,
+  // sets and hashes grow dynamically → extensible. Primitives are
+  // non-objects → ES2015 reports them sealed & frozen, not extensible.
+  const extKind = (obj) => {
+    const t = typeof obj === 'string' ? lookupValType(obj) : valTypeOf(obj)
+    if (t === VAL.OBJECT) return { ext: 0, sealed: 1, frozen: 0 }
+    if (t === VAL.NUMBER || t === VAL.STRING || t === VAL.BIGINT) return { ext: 0, sealed: 1, frozen: 1 }
+    return { ext: 1, sealed: 0, frozen: 0 }
+  }
+  const objQuery = (pick) => (obj) => {
+    const v = pick(extKind(obj))
+    if (obj == null) return typed(['f64.const', v], 'f64')
+    return typed(['block', ['result', 'f64'], ['drop', asF64(emit(obj))], ['f64.const', v]], 'f64')
+  }
+  ctx.core.emit['Object.isExtensible'] = objQuery((k) => k.ext)
+  ctx.core.emit['Object.isSealed'] = objQuery((k) => k.sealed)
+  ctx.core.emit['Object.isFrozen'] = objQuery((k) => k.frozen)
+
+  // RequireObjectCoercible: Object.keys/values/entries reject null & undefined
+  // with a TypeError. A literal lowers to a [null, value] node — so `null` is
+  // [null, null] and `undefined` is [null, undefined] (both JSON-print alike);
+  // a missing argument arrives as JS undefined. Anything else (incl.
+  // booleans/numbers, which JS boxes) is left to the normal path.
+  const isNullishLiteral = (node) => node === undefined
+    || (Array.isArray(node) && node.length === 2 && node[0] == null && node[1] == null)
+  const requireCoercible = (node) => {
+    if (!isNullishLiteral(node)) return null
+    ctx.runtime.throws = true
+    return typed(['block', ['result', 'f64'], ['throw', '$__jz_err', ['f64.const', 0]]], 'f64')
+  }
+
+  // Arrays and (coerced) strings expose their indices as own enumerable
+  // keys — Object.keys/entries iterate "0".."n-1". `arrayValType` mirrors
+  // `stringValType` below: a string arg is a variable name, anything else
+  // an AST node.
+  const arrayValType = (obj) => (typeof obj === 'string' ? lookupValType(obj) : valTypeOf(obj)) === VAL.ARRAY
+  // Index-string key array for an array-like receiver. `lenCall` is the
+  // length builtin: __len for jz arrays, __str_len for strings.
+  const emitIndexKeys = (obj, lenCall) => {
+    inc(lenCall, '__to_str')
+    const v = temp('ik'), i = tempI32('iki'), len = tempI32('ikl')
+    const vPtr = () => ['i64.reinterpret_f64', ['local.get', `$${v}`]]
+    const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${len}`], tag: 'ik' })
+    const id = ctx.func.uniq++
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${v}`, asF64(emit(obj))],
+      ['local.set', `$${len}`, ['call', `$${lenCall}`, vPtr()]],
+      out.init,
+      ['local.set', `$${i}`, ['i32.const', 0]],
+      ['block', `$brk${id}`, ['loop', `$loop${id}`,
+        ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+        elemStore(out.local, i, ['f64.reinterpret_i64',
+          ['call', '$__to_str', ['i64.reinterpret_f64', ['f64.convert_i32_s', ['local.get', `$${i}`]]]]]),
+        ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+        ['br', `$loop${id}`]]],
+      out.ptr], 'f64')
+  }
+
   ctx.core.emit['Object.keys'] = (obj) => {
+    const nullish = requireCoercible(obj)
+    if (nullish) return nullish
     if (isHashTyped(obj)) return emitHashKeys(obj)
+    if (arrayValType(obj)) return emitIndexKeys(obj, '__len')
+    if (stringValType(obj)) return emitIndexKeys(obj, '__str_len')
     const schema = resolveSchema(obj)
     if (schema) return emitStringArray(schema)
     // Receiver type unknown at compile time. Dispatch on ptr-type at
     // runtime: HASH walks the probe table, anything else returns [].
     return emitRuntimeKeys(obj)
   }
+  ctx.core.emit['Object.getOwnPropertyNames'] = ctx.core.emit['Object.keys']
 
   // Object.prototype.hasOwnProperty(key) — own-property presence check.
   // Compile-time fold for literal keys against object literals or variables
@@ -132,8 +204,36 @@ export default (ctx) => {
   ctx.core.emit[`.${VAL.ARRAY}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
   ctx.core.emit[`.${VAL.STRING}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
   ctx.core.emit[`.${VAL.CLOSURE}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
+  // Object.hasOwn(o, k) — ES2022 static equivalent of o.hasOwnProperty(k).
+  // Reuses the same own-property emitter; receiver-type variants above apply.
+  ctx.core.emit['Object.hasOwn'] = (obj, key) => ctx.core.emit['.hasOwnProperty'](obj, key)
+
+  // String primitives are coerced to exotic String objects whose own enumerable
+  // properties are the indexed characters. Object.values/entries iterate them.
+  const stringValType = (obj) => (typeof obj === 'string' ? lookupValType(obj) : valTypeOf(obj)) === VAL.STRING
 
   ctx.core.emit['Object.values'] = (obj) => {
+    const nullish = requireCoercible(obj)
+    if (nullish) return nullish
+    if (stringValType(obj)) {
+      inc('__str_idx', '__str_len')
+      const s = temp('osv'), i = tempI32('osvi'), len = tempI32('osvl')
+      const sPtr = () => ['i64.reinterpret_f64', ['local.get', `$${s}`]]
+      const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${len}`], tag: 'osv' })
+      const id = ctx.func.uniq++
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${s}`, asF64(emit(obj))],
+        ['local.set', `$${len}`, ['call', '$__str_len', sPtr()]],
+        out.init,
+        ['local.set', `$${i}`, ['i32.const', 0]],
+        ['block', `$brk${id}`, ['loop', `$loop${id}`,
+          ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+          elemStore(out.local, i, ['call', '$__str_idx', sPtr(), ['local.get', `$${i}`]]),
+          ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+          ['br', `$loop${id}`]]],
+        out.ptr], 'f64')
+    }
+    if (arrayValType(obj)) { inc('__arr_from'); return typed(['call', '$__arr_from', asI64(emit(obj))], 'f64') }
     if (isHashTyped(obj)) return emitHashValues(obj)
     const schema = resolveSchema(obj)
     if (!schema) return emitRuntimeValues(obj)
@@ -144,14 +244,62 @@ export default (ctx) => {
     const body = [['local.set', `$${t}`, va], out.init,
       ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]]
     for (let i = 0; i < n; i++)
-      body.push(['f64.store', slotAddr(out.local, i), ['f64.load', slotAddr(base, i)]])
+      body.push(['f64.store', slotAddr(out.local, i), ctx.abi.object.ops.load(['local.get', `$${base}`], i)])
     body.push(out.ptr)
     return typed(['block', ['result', 'f64'], ...body], 'f64')
   }
 
   ctx.core.emit['Object.entries'] = (obj) => {
+    const nullish = requireCoercible(obj)
+    if (nullish) return nullish
+    if (stringValType(obj)) {
+      inc('__str_idx', '__str_len', '__to_str')
+      const s = temp('oes'), i = tempI32('oesi'), len = tempI32('oesl'), pair = tempI32('oep')
+      const sPtr = () => ['i64.reinterpret_f64', ['local.get', `$${s}`]]
+      const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${len}`], tag: 'oes' })
+      const id = ctx.func.uniq++
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${s}`, asF64(emit(obj))],
+        ['local.set', `$${len}`, ['call', '$__str_len', sPtr()]],
+        out.init,
+        ['local.set', `$${i}`, ['i32.const', 0]],
+        ['block', `$brk${id}`, ['loop', `$loop${id}`,
+          ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+          ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+          ['f64.store', slotAddr(pair, 0), ['f64.reinterpret_i64',
+            ['call', '$__to_str', ['i64.reinterpret_f64', ['f64.convert_i32_s', ['local.get', `$${i}`]]]]]],
+          ['f64.store', slotAddr(pair, 1), ['call', '$__str_idx', sPtr(), ['local.get', `$${i}`]]],
+          elemStore(out.local, i, mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])),
+          ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+          ['br', `$loop${id}`]]],
+        out.ptr], 'f64')
+    }
+    if (arrayValType(obj)) {
+      inc('__len', '__to_str', '__ptr_offset', '__alloc_hdr')
+      const v = temp('oea'), i = tempI32('oeai'), len = tempI32('oeal'), base = tempI32('oeab'), pair = tempI32('oeap')
+      const vPtr = () => ['i64.reinterpret_f64', ['local.get', `$${v}`]]
+      const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${len}`], tag: 'oea' })
+      const id = ctx.func.uniq++
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${v}`, asF64(emit(obj))],
+        ['local.set', `$${len}`, ['call', '$__len', vPtr()]],
+        out.init,
+        ['local.set', `$${base}`, ['call', '$__ptr_offset', vPtr()]],
+        ['local.set', `$${i}`, ['i32.const', 0]],
+        ['block', `$brk${id}`, ['loop', `$loop${id}`,
+          ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+          ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+          ['f64.store', slotAddr(pair, 0), ['f64.reinterpret_i64',
+            ['call', '$__to_str', ['i64.reinterpret_f64', ['f64.convert_i32_s', ['local.get', `$${i}`]]]]]],
+          ['f64.store', slotAddr(pair, 1), elemLoad(base, i)],
+          elemStore(out.local, i, mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])),
+          ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+          ['br', `$loop${id}`]]],
+        out.ptr], 'f64')
+    }
+    if (isHashTyped(obj)) return emitHashEntries(obj)
     const schema = resolveSchema(obj)
-    if (!schema) err('Object.entries requires object with known schema')
+    if (!schema) return emitRuntimeEntries(obj)
     const va = asF64(emit(obj))
     const n = schema.length
     const t = temp('oe'), pair = tempI32('op'), base = tempI32('eb')
@@ -160,9 +308,9 @@ export default (ctx) => {
       ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]]
     for (let i = 0; i < n; i++) {
       body.push(
-        ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2], ['i32.const', 8]]],
+        ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
         ['f64.store', slotAddr(pair, 0), emit(['str', schema[i]])],
-        ['f64.store', slotAddr(pair, 1), ['f64.load', slotAddr(base, i)]],
+        ['f64.store', slotAddr(pair, 1), ctx.abi.object.ops.load(['local.get', `$${base}`], i)],
         ['f64.store', slotAddr(out.local, i), mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])])
     }
     body.push(out.ptr)
@@ -170,6 +318,9 @@ export default (ctx) => {
   }
 
   ctx.core.emit['Object.assign'] = (target, ...sources) => {
+    // RequireObjectCoercible(target) — null/undefined is a TypeError.
+    const nullish = requireCoercible(target)
+    if (nullish) return nullish
     if (typeof target === 'string') {
       const vt = repOf(target)?.val
       if (vt && vt !== VAL.OBJECT) {
@@ -182,11 +333,14 @@ export default (ctx) => {
         const boxedSchema = ['__inner__', ...allProps]
         const schemaId = ctx.schema.register(boxedSchema)
         ctx.schema.vars.set(target, schemaId)
+        // Emit-time rep mutation: Object.assign's target gains a freshly-registered
+        // boxed-schema binding here; downstream `.prop` reads in the same emit pass
+        // depend on schemaId being live on the rep, not just in ctx.schema.vars.
         updateRep(target, { schemaId })
         const t = tempI32('bx'), s = temp('bs')
         const body = [
-          ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, boxedSchema.length)], ['i32.const', 8]]],
-          ['f64.store', ['local.get', `$${t}`], asF64(emit(target))],
+          ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(boxedSchema.length)]]],
+          ctx.abi.object.ops.store(['local.get', `$${t}`], 0, asF64(emit(target))),
         ]
         const sBase = tempI32('sb')
         for (const source of sources) {
@@ -196,7 +350,7 @@ export default (ctx) => {
           for (let si = 0; si < sSchema.length; si++) {
             const ti = boxedSchema.indexOf(sSchema[si])
             if (ti < 0) continue
-            body.push(['f64.store', slotAddr(t, ti), ['f64.load', slotAddr(sBase, si)]])
+            body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], ti, ctx.abi.object.ops.load(['local.get', `$${sBase}`], si)))
           }
         }
         body.push(['local.set', `$${target}`,
@@ -206,20 +360,22 @@ export default (ctx) => {
       }
     }
     const tSchema = resolveSchema(target)
+    const sourceSchemas = sources.map(resolveSchema)
     if (!tSchema) err('Object.assign: target needs known schema')
+    if (sourceSchemas.some(s => !s)) return emitDynamicAssign(target, sources, sourceSchemas)
     const t = temp('at'), s = temp('as')
     const tBase = tempI32('tb'), sBase2 = tempI32('sb')
     const body = [['local.set', `$${t}`, asF64(emit(target))],
       ['local.set', `$${tBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]]]
-    for (const source of sources) {
-      const sSchema = resolveSchema(source)
-      if (!sSchema) err('Object.assign: source needs known schema')
+    for (let i = 0; i < sources.length; i++) {
+      const source = sources[i]
+      const sSchema = sourceSchemas[i]
       body.push(['local.set', `$${s}`, asF64(emit(source))])
       body.push(['local.set', `$${sBase2}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]])
       for (let si = 0; si < sSchema.length; si++) {
         const ti = tSchema.indexOf(sSchema[si])
         if (ti < 0) continue
-        body.push(['f64.store', slotAddr(tBase, ti), ['f64.load', slotAddr(sBase2, si)]])
+        body.push(ctx.abi.object.ops.store(['local.get', `$${tBase}`], ti, ctx.abi.object.ops.load(['local.get', `$${sBase2}`], si)))
       }
     }
     body.push(['local.get', `$${t}`])
@@ -230,8 +386,12 @@ export default (ctx) => {
     err('Object.defineProperty descriptor semantics are outside jz scope; jzify only folds static bundler export helpers')
   }
 
-  // Object.fromEntries(arr) → creates HASH from array of [key, value] pairs
+  // Object.fromEntries(arr) → creates HASH from array of [key, value] pairs.
+  // Spec step 1 is RequireObjectCoercible(iterable): a missing/nullish argument
+  // is a TypeError, not an `emit(undefined)` compiler crash.
   ctx.core.emit['Object.fromEntries'] = (arr) => {
+    const nullishThrow = requireCoercible(arr)
+    if (nullishThrow) return nullishThrow
     inc('__hash_new', '__hash_set')
     inc('__str_hash', '__str_eq')
     const va = asF64(emit(arr))
@@ -266,6 +426,7 @@ export default (ctx) => {
       // Header propsPtr lives at $off-16 (current ARRAY layout). We alias src's hash
       // by copying the slot; __dyn_move covers the shifted-array case where props
       // were migrated to the global __dyn_props.
+      includeModule('array')
       inc('__arr_from', '__dyn_move', '__ptr_offset')
       const src = temp('ocs')
       const dst = temp('ocd')
@@ -288,6 +449,7 @@ export default (ctx) => {
     if (!schema) {
       if (protoType == null) {
         const value = temp('ocr')
+        includeModule('array')
         inc('__arr_from', '__dyn_move', '__ptr_offset')
         const dst2 = temp('ocd')
         const srcOff2 = tempI32('ocso')
@@ -317,12 +479,12 @@ export default (ctx) => {
     const srcBase = tempI32('cb')
     const body = [
       ['local.set', `$${s}`, asF64(emit(proto))],
-      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, n)], ['i32.const', 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(n)]]],
       ['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]],
     ]
     // Copy all properties from proto
     for (let i = 0; i < n; i++)
-      body.push(['f64.store', slotAddr(t, i), ['f64.load', slotAddr(srcBase, i)]])
+      body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], i, ctx.abi.object.ops.load(['local.get', `$${srcBase}`], i)))
     body.push(mkPtrIR(PTR.OBJECT, schemaId, ['local.get', `$${t}`]))
     return typed(['block', ['result', 'f64'], ...body], 'f64')
   }
@@ -330,6 +492,57 @@ export default (ctx) => {
 
 // --- Helpers ---
 
+// Used only after the target schema is known. Unknown HASH targets can grow by
+// returning a new pointer, which would not preserve aliases to the old value.
+function emitDynamicAssign(target, sources, sourceSchemas = sources.map(resolveSchema)) {
+  includeModule('collection')
+  inc('__hash_set', '__dyn_get_any', '__ptr_offset', '__len')
+  const t = temp('adt'), s = temp('ads'), sBase = tempI32('adsb')
+  const keys = temp('adk'), keysBase = tempI32('adkb'), len = tempI32('adn')
+  const i = tempI32('adi'), key = temp('adkey')
+  const id = ctx.func.uniq++
+  const body = [['local.set', `$${t}`, asF64(emit(target))]]
+
+  for (let si = 0; si < sources.length; si++) {
+    const source = sources[si]
+    const sSchema = sourceSchemas[si]
+    body.push(['local.set', `$${s}`, asF64(emit(source))])
+    if (sSchema) {
+      body.push(['local.set', `$${sBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]])
+      for (let pi = 0; pi < sSchema.length; pi++)
+        body.push(['local.set', `$${t}`, ['f64.reinterpret_i64',
+          ['call', '$__hash_set', ['i64.reinterpret_f64', ['local.get', `$${t}`]],
+            asI64(emit(['str', String(sSchema[pi])])),
+            ctx.abi.object.ops.loadBits(['local.get', `$${sBase}`], pi)]]])
+      continue
+    }
+
+    body.push(
+      ['local.set', `$${keys}`, runtimeKeysFromTemp(s, 'adk')],
+      ['local.set', `$${keysBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${keys}`]]]],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${keys}`]]]],
+      ['local.set', `$${i}`, ['i32.const', 0]],
+      ['block', `$adbrk${id}_${si}`, ['loop', `$adloop${id}_${si}`,
+        ['br_if', `$adbrk${id}_${si}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${len}`]]],
+        ['local.set', `$${key}`, ['f64.load',
+          ['i32.add', ['local.get', `$${keysBase}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+        ['local.set', `$${t}`, ['f64.reinterpret_i64',
+          ['call', '$__hash_set',
+            ['i64.reinterpret_f64', ['local.get', `$${t}`]],
+            ['i64.reinterpret_f64', ['local.get', `$${key}`]],
+            ['call', '$__dyn_get_any',
+              ['i64.reinterpret_f64', ['local.get', `$${s}`]],
+              ['i64.reinterpret_f64', ['local.get', `$${key}`]]]]]],
+        ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+        ['br', `$adloop${id}_${si}`]]])
+  }
+
+  if (typeof target === 'string' && ctx.func.locals.get(target) === 'f64')
+    body.push(['local.set', `$${target}`, ['local.get', `$${t}`]])
+  body.push(['local.get', `$${t}`])
+  return typed(['block', ['result', 'f64'], ...body], 'f64')
+}
+
 function resolveSchema(obj) {
   if (typeof obj === 'string') return ctx.schema.resolve(obj)
   if (Array.isArray(obj) && obj[0] === '{}')
@@ -337,7 +550,7 @@ function resolveSchema(obj) {
   // JSON-shape inferred: JSON.parse(constStr) call or `.prop`/`[i]` chain
   // resolving to a known OBJECT shape carries its key list as `names`.
   const sh = shapeOf(obj)
-  if (sh?.vt === VAL.OBJECT && sh.names) return sh.names
+  if (sh?.val === VAL.OBJECT && sh.names) return sh.names
   return null
 }
 
@@ -378,7 +591,7 @@ function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
   const ptr = temp('objp')
   const src = tempI32('osp')
 
-  const body = [['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]]]
+  const body = [['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', ctx.abi.object.ops.allocSlots(schema.length)]]]]
 
   // Process props in order — later props override earlier (JS semantics)
   let srcF
@@ -387,17 +600,17 @@ function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
       const sSchema = resolveSchema(p[1])
       if (!sSchema) {
         // Unknown-schema source (e.g. parameter). Override each slot via runtime
-        // __dyn_get_or using existing value as fallback. Requires collection module.
-        if (!ctx.module.modules.collection) err('Object spread: source needs known schema')
+        // __dyn_get_or using existing value as fallback.
+        includeModule('collection')
         inc('__dyn_get_or')
         srcF ??= temp('ospf')
         body.push(['local.set', `$${srcF}`, asF64(emit(p[1]))])
         for (let i = 0; i < schema.length; i++) {
-          const slot = slotAddr(t, i)
-          body.push(['f64.store', slot,
+          const base = ['local.get', `$${t}`]
+          body.push(ctx.abi.object.ops.store(base, i,
             ['f64.reinterpret_i64', ['call', '$__dyn_get_or', ['i64.reinterpret_f64', ['local.get', `$${srcF}`]],
               asI64(emit(['str', String(schema[i])])),
-              ['i64.load', slot]]]])
+              ctx.abi.object.ops.loadBits(base, i)]]))
         }
         continue
       }
@@ -405,11 +618,11 @@ function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
       for (let si = 0; si < sSchema.length; si++) {
         const ti = schema.indexOf(sSchema[si])
         if (ti < 0) continue
-        body.push(['f64.store', slotAddr(t, ti), ['f64.load', slotAddr(src, si)]])
+        body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], ti, ctx.abi.object.ops.load(['local.get', `$${src}`], si)))
       }
     } else if (Array.isArray(p) && p[0] === ':') {
       const ti = schema.indexOf(p[1])
-      if (ti >= 0) body.push(['f64.store', slotAddr(t, ti), asF64(emit(p[2]))])
+      if (ti >= 0) body.push(ctx.abi.object.ops.store(['local.get', `$${t}`], ti, asF64(emit(p[2]))))
     }
   }
 
@@ -418,7 +631,7 @@ function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
     inc('__dyn_set')
     for (let i = 0; i < schema.length; i++)
       body.push(['drop', ['call', '$__dyn_set', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], asI64(emit(['str', String(schema[i])])),
-        ['i64.load', slotAddr(t, i)]]])
+        ctx.abi.object.ops.loadBits(['local.get', `$${t}`], i)]])
   }
   body.push(['local.get', `$${ptr}`])
   return typed(['block', ['result', 'f64'], ...body], 'f64')
@@ -462,6 +675,13 @@ function emitHashValues(obj) {
     hashValuesFromTemp(t)], 'f64')
 }
 
+function emitHashEntries(obj) {
+  const t = temp('he')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    hashEntriesFromTemp(t)], 'f64')
+}
+
 // Inline body of the HASH walk against an already-bound f64 local. Shared by
 // the static-HASH path and the runtime-dispatch path so both produce the same
 // IR shape from the same source — only difference is whether they enter from
@@ -520,22 +740,59 @@ function hashValuesFromTemp(t) {
     out.ptr]
 }
 
+function hashEntriesFromTemp(t) {
+  inc('__ptr_offset', '__cap', '__len', '__alloc_hdr')
+  const off = tempI32('heo'), cap = tempI32('hec'), n = tempI32('hen')
+  const i = tempI32('hei'), o = tempI32('hej'), slot = tempI32('hes'), pair = tempI32('hep')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'hea' })
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${n}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    out.init,
+    ['local.set', `$${off}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${cap}`, ['call', '$__cap', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['local.set', `$${o}`, ['i32.const', 0]],
+    ['block', `$ebrk${id}`, ['loop', `$eloop${id}`,
+      ['br_if', `$ebrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+      ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
+        ['i32.mul', ['local.get', `$${i}`], ['i32.const', 24]]]],
+      ['if', ['f64.ne', ['f64.load', ['local.get', `$${slot}`]], ['f64.const', 0]],
+        ['then',
+          ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+          ['f64.store', ['local.get', `$${pair}`],
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 8]]]],
+          ['f64.store', ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]],
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 16]]]],
+          elemStore(out.local, o, mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])),
+          ['local.set', `$${o}`, ['i32.add', ['local.get', `$${o}`], ['i32.const', 1]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$eloop${id}`]]],
+    out.ptr]
+}
+
 // Type-unknown receiver: bind the value, branch on ptr-type. HASH walks the
 // probe table; OBJECT loads the schema's key array (registered statically at
 // compile time or lazily at runtime by JSON.parse via __jp_schema_get); other
 // types (ARRAY, nullish, primitives) return an empty array. The empty-array
 // fallback is allocated in all arms for type uniformity at the if boundary.
 function emitRuntimeKeys(obj) {
+  const t = temp('rk')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    runtimeKeysFromTemp(t, 'rk')], 'f64')
+}
+
+function runtimeKeysFromTemp(t, tag) {
   inc('__ptr_type')
   // Ensure the schema table global exists even in programs that never use
   // JSON.parse or compile-time schemas — the OBJECT arm reads it at runtime
   // and the watr resolver requires the symbol to be declared.
   if (!ctx.scope.globals.has('__schema_tbl'))
     ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
-  const t = temp('rk'), tt = tempI32('rkt')
-  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: 'rke' })
-  return typed(['block', ['result', 'f64'],
-    ['local.set', `$${t}`, asF64(emit(obj))],
+  const tt = tempI32(`${tag}t`)
+  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: `${tag}e` })
+  return ['block', ['result', 'f64'],
     ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
     ['if', ['result', 'f64'],
       ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.HASH]],
@@ -545,7 +802,7 @@ function emitRuntimeKeys(obj) {
           ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.OBJECT]],
           ['i32.ne', ['global.get', '$__schema_tbl'], ['i32.const', 0]]],
         ['then', objectKeysFromTemp(t)],
-        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
+        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]]
 }
 
 function emitRuntimeValues(obj) {
@@ -568,6 +825,26 @@ function emitRuntimeValues(obj) {
         ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
 }
 
+function emitRuntimeEntries(obj) {
+  inc('__ptr_type')
+  if (!ctx.scope.globals.has('__schema_tbl'))
+    ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  const t = temp('re'), tt = tempI32('ret')
+  const empty = allocPtr({ type: PTR.ARRAY, len: 0, tag: 'ree' })
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['if', ['result', 'f64'],
+      ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.HASH]],
+      ['then', hashEntriesFromTemp(t)],
+      ['else', ['if', ['result', 'f64'],
+        ['i32.and',
+          ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.OBJECT]],
+          ['i32.ne', ['global.get', '$__schema_tbl'], ['i32.const', 0]]],
+        ['then', objectEntriesFromTemp(t)],
+        ['else', ['block', ['result', 'f64'], empty.init, empty.ptr]]]]]], 'f64')
+}
+
 // Schema-keyed Object.keys: copy the schema's keys array (a jz Array of
 // STRINGs registered in __schema_tbl[sid]) into a fresh ARRAY so callers can
 // mutate without aliasing the schema substrate.
@@ -584,7 +861,7 @@ function objectKeysFromTemp(t) {
       ['i64.const', LAYOUT.OFFSET_MASK]]]],
     ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
     ['local.set', `$${out}`, ['call', '$__alloc_hdr',
-      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
     ['local.set', `$${i}`, ['i32.const', 0]],
     ['block', `$kbrk${id}`, ['loop', `$kloop${id}`,
       ['br_if', `$kbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
@@ -612,7 +889,7 @@ function objectValuesFromTemp(t) {
     ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
     ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
     ['local.set', `$${out}`, ['call', '$__alloc_hdr',
-      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
     ['local.set', `$${i}`, ['i32.const', 0]],
     ['block', `$ovbrk${id}`, ['loop', `$ovloop${id}`,
       ['br_if', `$ovbrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
@@ -624,3 +901,39 @@ function objectValuesFromTemp(t) {
       ['br', `$ovloop${id}`]]],
     mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
 }
+
+function objectEntriesFromTemp(t) {
+  inc('__alloc_hdr', '__ptr_offset')
+  const sid = tempI32('oes'), src = tempI32('oesrc'), n = tempI32('oen')
+  const base = tempI32('oebase'), out = tempI32('oeo'), i = tempI32('oei'), pair = tempI32('oep')
+  const id = ctx.func.uniq++
+  return ['block', ['result', 'f64'],
+    ['local.set', `$${sid}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.shr_u', ['i64.reinterpret_f64', ['local.get', `$${t}`]], ['i64.const', LAYOUT.AUX_SHIFT]],
+      ['i64.const', LAYOUT.AUX_MASK]]]],
+    ['local.set', `$${src}`, ['i32.wrap_i64', ['i64.and',
+      ['i64.load', ['i32.add', ['global.get', '$__schema_tbl'], ['i32.shl', ['local.get', `$${sid}`], ['i32.const', 3]]]],
+      ['i64.const', LAYOUT.OFFSET_MASK]]]],
+    ['local.set', `$${n}`, ['i32.load', ['i32.sub', ['local.get', `$${src}`], ['i32.const', 8]]]],
+    ['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
+    ['local.set', `$${out}`, ['call', '$__alloc_hdr',
+      ['local.get', `$${n}`], ['local.get', `$${n}`]]],
+    ['local.set', `$${i}`, ['i32.const', 0]],
+    ['block', `$oebrk${id}`, ['loop', `$oeloop${id}`,
+      ['br_if', `$oebrk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${n}`]]],
+      ['local.set', `$${pair}`, ['call', '$__alloc_hdr', ['i32.const', 2], ['i32.const', 2]]],
+      ['i64.store',
+        ['local.get', `$${pair}`],
+        ['i64.load',
+          ['i32.add', ['local.get', `$${src}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]],
+        ['f64.load',
+          ['i32.add', ['local.get', `$${base}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['f64.store',
+        ['i32.add', ['local.get', `$${out}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]],
+        mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${pair}`])],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$oeloop${id}`]]],
+    mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
+}