jz 0.1.0 → 0.2.0

package/module/object.js

@@ -7,34 +7,51 @@
  * @module object
  */
 
-import { emit, typed, asF64, valTypeOf, lookupValType, VAL, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr, repOf, updateRep } from '../src/compile.js'
-import { ctx, err, inc, PTR } from '../src/ctx.js'
+import { typed, asF64, asI64, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr, 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'
 
 
 export default (ctx) => {
   inc('__mkptr', '__alloc', '__alloc_hdr', '__ptr_offset', '__len', '__ptr_type')
 
-  // Object literal: {x: 1, y: 2} → allocate, fill, return pointer with schemaId
+  // Object literal: {x: 1, y: 2} → allocate, fill, return pointer with schemaId.
+  // OBJECT alloc uses __alloc_hdr (16-byte header at off-16) to enable per-object
+  // propsPtr — dyn property writes (e.g. `ctx.metadata = {}` in watr) hit the
+  // per-object hash directly, skipping the global __dyn_props probe. The
+  // header gate `off >= __heap_start` keeps static-segment objects on the
+  // global-hash path (their off-16 belongs to neighboring static slots).
   ctx.core.emit['{}'] = (...rawProps) => {
-    if (rawProps.length === 0)
-      return mkPtrIR(PTR.OBJECT, 0, ['call', '$__alloc', ['i32.const', 8]])
+    if (rawProps.length === 0) {
+      // Honor the literal target's autobox/merged schema so `let ctx = {}` followed
+      // by `ctx.meta = ...` allocates with the right cap. Otherwise the default
+      // cap=1 alloc overwrites the autobox preamble's wrapper, and subsequent
+      // 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]])
+    }
 
     // Flatten comma-grouped props: [',', p1, p2] → [p1, p2]
     const props = rawProps.length === 1 && Array.isArray(rawProps[0]) && rawProps[0][0] === ','
       ? rawProps[0].slice(1) : rawProps
 
+    const target = takeLiteralTarget()
+
     // Object spread: {...a, x: 1, ...b} — merge schemas, copy props from sources
     const hasSpreads = props.some(p => Array.isArray(p) && p[0] === '...')
-    if (hasSpreads) return emitObjectSpread(props)
+    if (hasSpreads) return emitObjectSpread(props, target)
 
     const names = [], values = []
     for (const p of props) {
       if (Array.isArray(p) && p[0] === ':') { names.push(p[1]); values.push(p[2]) }
     }
 
-    // Use variable's merged schema if available (from Object.assign inference), else register literal schema
+    // Use variable's merged schema if available (from Object.assign inference), else register literal schema.
     let schemaId = ctx.schema.register(names)
-    const target = ctx.schema.targetStack.at(-1)
     if (target) {
       const merged = ctx.schema.resolve(target)
       if (merged) schemaId = ctx.schema.idOf(target)
@@ -57,15 +74,15 @@ export default (ctx) => {
         inc('__dyn_set')
         const body = [['local.set', `$${ptr}`, staticPtr]]
         for (let i = 0; i < schema.length; i++)
-          body.push(['drop', ['call', '$__dyn_set', ['local.get', `$${ptr}`],
-            emit(['str', String(schema[i])]), asF64(emitted[i])]])
+          body.push(['drop', ['call', '$__dyn_set', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]],
+            asI64(emit(['str', String(schema[i])])), asI64(emitted[i])]])
         body.push(['local.get', `$${ptr}`])
         return typed(['block', ['result', 'f64'], ...body], 'f64')
       }
     }
 
     const body = [
-      ['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', schema.length * 8]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
     ]
     for (let i = 0; i < values.length; i++)
       body.push(['f64.store', slotAddr(t, i), asF64(emit(values[i]))])
@@ -73,8 +90,8 @@ export default (ctx) => {
     if (shadow) {
       inc('__dyn_set')
       for (let i = 0; i < schema.length; i++)
-        body.push(['drop', ['call', '$__dyn_set', ['local.get', `$${ptr}`], emit(['str', String(schema[i])]),
-          ['f64.load', slotAddr(t, i)]]])
+        body.push(['drop', ['call', '$__dyn_set', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], asI64(emit(['str', String(schema[i])])),
+          ['i64.load', slotAddr(t, i)]]])
     }
     body.push(['local.get', `$${ptr}`])
 
@@ -84,10 +101,37 @@ export default (ctx) => {
   // === Object static methods ===
 
   ctx.core.emit['Object.keys'] = (obj) => {
+    if (isHashTyped(obj)) return emitHashKeys(obj)
     const schema = resolveSchema(obj)
-    if (!schema) err('Object.keys requires object with known schema')
-    return emitStringArray(schema)
+    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)
+  }
+
+  // Object.prototype.hasOwnProperty(key) — own-property presence check.
+  // Compile-time fold for literal keys against object literals or variables
+  // with known schemas; runtime path delegates to the `in` operator (same
+  // ptr-type dispatch + __hash_has for HASH, dyn_props probe for OBJECT).
+  ctx.core.emit['.hasOwnProperty'] = (obj, key) => {
+    const litKey = Array.isArray(key) && key[0] === 'str' ? String(key[1]) : null
+    if (litKey != null) {
+      if (Array.isArray(obj) && obj[0] === '{}') {
+        const has = obj.slice(1).some(p => Array.isArray(p) && p[0] === ':' && String(p[1]) === litKey)
+        return typed(['block', ['result', 'f64'],
+          ['drop', asF64(emit(obj))],
+          ['f64.const', has ? 1 : 0]], 'f64')
+      }
+      if (typeof obj === 'string' && ctx.schema.find?.(obj, litKey) >= 0)
+        return typed(['f64.const', 1], 'f64')
+    }
+    return typed(['f64.convert_i32_s', emit(['in', key, obj])], 'f64')
   }
+  ctx.core.emit[`.${VAL.HASH}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
+  ctx.core.emit[`.${VAL.OBJECT}:hasOwnProperty`] = ctx.core.emit['.hasOwnProperty']
+  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']
 
   ctx.core.emit['Object.values'] = (obj) => {
     const schema = resolveSchema(obj)
@@ -97,7 +141,7 @@ export default (ctx) => {
     const t = temp('ov'), base = tempI32('vb')
     const out = allocPtr({ type: PTR.ARRAY, len: n, tag: 'oa' })
     const body = [['local.set', `$${t}`, va], out.init,
-      ['local.set', `$${base}`, ['call', '$__ptr_offset', ['local.get', `$${t}`]]]]
+      ['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(out.ptr)
@@ -112,7 +156,7 @@ export default (ctx) => {
     const t = temp('oe'), pair = tempI32('op'), base = tempI32('eb')
     const out = allocPtr({ type: PTR.ARRAY, len: n, tag: 'oa' })
     const body = [['local.set', `$${t}`, va], out.init,
-      ['local.set', `$${base}`, ['call', '$__ptr_offset', ['local.get', `$${t}`]]]]
+      ['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]]],
@@ -140,14 +184,14 @@ export default (ctx) => {
         updateRep(target, { schemaId })
         const t = tempI32('bx'), s = temp('bs')
         const body = [
-          ['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', boxedSchema.length * 8]]],
+          ['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))],
         ]
         const sBase = tempI32('sb')
         for (const source of sources) {
           const sSchema = resolveSchema(source)
           body.push(['local.set', `$${s}`, asF64(emit(source))])
-          body.push(['local.set', `$${sBase}`, ['call', '$__ptr_offset', ['local.get', `$${s}`]]])
+          body.push(['local.set', `$${sBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]])
           for (let si = 0; si < sSchema.length; si++) {
             const ti = boxedSchema.indexOf(sSchema[si])
             if (ti < 0) continue
@@ -165,12 +209,12 @@ export default (ctx) => {
     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', ['local.get', `$${t}`]]]]
+      ['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')
       body.push(['local.set', `$${s}`, asF64(emit(source))])
-      body.push(['local.set', `$${sBase2}`, ['call', '$__ptr_offset', ['local.get', `$${s}`]]])
+      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
@@ -191,18 +235,18 @@ export default (ctx) => {
     const id = ctx.func.uniq++
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${t}`, ['call', '$__hash_new']],
-      ['local.set', `$${ptr}`, ['call', '$__ptr_offset', va]],
-      ['local.set', `$${len}`, ['call', '$__len', va]],
+      ['local.set', `$${ptr}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', va]]],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', va]]],
       ['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}`]]],
         // Load pair (array of 2): pair = ptr_offset(arr[i])
-        ['local.set', `$${pair}`, ['call', '$__ptr_offset',
-          ['f64.load', ['i32.add', ['local.get', `$${ptr}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]]],
+        ['local.set', `$${pair}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64',
+          ['f64.load', ['i32.add', ['local.get', `$${ptr}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]]]],
         // hash_set(result, pair[0], pair[1])
-        ['local.set', `$${t}`, ['call', '$__hash_set', ['local.get', `$${t}`],
-          ['f64.load', ['local.get', `$${pair}`]],
-          ['f64.load', ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]]]]],
+        ['local.set', `$${t}`, ['f64.reinterpret_i64', ['call', '$__hash_set', ['i64.reinterpret_f64', ['local.get', `$${t}`]],
+          ['i64.load', ['local.get', `$${pair}`]],
+          ['i64.load', ['i32.add', ['local.get', `$${pair}`], ['i32.const', 8]]]]]],
         ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
         ['br', `$loop${id}`]]],
       ['local.get', `$${t}`]], 'f64')
@@ -214,15 +258,25 @@ export default (ctx) => {
     if (protoType === VAL.ARRAY) {
       // Clone array data + link named-prop sidecar so for-in/bracket-name lookups
       // keep working after Object.create (watr's ctx.local = Object.create(param) pattern).
+      // 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.
       inc('__arr_from', '__dyn_move', '__ptr_offset')
       const src = temp('ocs')
       const dst = temp('ocd')
+      const srcOff = tempI32('ocso')
+      const dstOff = tempI32('ocdo')
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${src}`, asF64(emit(proto))],
-        ['local.set', `$${dst}`, ['call', '$__arr_from', ['local.get', `$${src}`]]],
+        ['local.set', `$${dst}`, ['call', '$__arr_from', ['i64.reinterpret_f64', ['local.get', `$${src}`]]]],
+        ['local.set', `$${srcOff}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${src}`]]]],
+        ['local.set', `$${dstOff}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${dst}`]]]],
+        ['f64.store',
+          ['i32.sub', ['local.get', `$${dstOff}`], ['i32.const', 16]],
+          ['f64.load', ['i32.sub', ['local.get', `$${srcOff}`], ['i32.const', 16]]]],
         ['call', '$__dyn_move',
-          ['call', '$__ptr_offset', ['local.get', `$${src}`]],
-          ['call', '$__ptr_offset', ['local.get', `$${dst}`]]],
+          ['local.get', `$${srcOff}`],
+          ['local.get', `$${dstOff}`]],
         ['local.get', `$${dst}`]], 'f64')
     }
     const schema = resolveSchema(proto)
@@ -231,15 +285,22 @@ export default (ctx) => {
         const value = temp('ocr')
         inc('__arr_from', '__dyn_move', '__ptr_offset')
         const dst2 = temp('ocd')
+        const srcOff2 = tempI32('ocso')
+        const dstOff2 = tempI32('ocdo')
         return typed(['block', ['result', 'f64'],
           ['local.set', `$${value}`, asF64(emit(proto))],
           ['if', ['result', 'f64'],
-            ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${value}`]], ['i32.const', PTR.ARRAY]],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${value}`]]], ['i32.const', PTR.ARRAY]],
             ['then', ['block', ['result', 'f64'],
-              ['local.set', `$${dst2}`, ['call', '$__arr_from', ['local.get', `$${value}`]]],
+              ['local.set', `$${dst2}`, ['call', '$__arr_from', ['i64.reinterpret_f64', ['local.get', `$${value}`]]]],
+              ['local.set', `$${srcOff2}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${value}`]]]],
+              ['local.set', `$${dstOff2}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${dst2}`]]]],
+              ['f64.store',
+                ['i32.sub', ['local.get', `$${dstOff2}`], ['i32.const', 16]],
+                ['f64.load', ['i32.sub', ['local.get', `$${srcOff2}`], ['i32.const', 16]]]],
               ['call', '$__dyn_move',
-                ['call', '$__ptr_offset', ['local.get', `$${value}`]],
-                ['call', '$__ptr_offset', ['local.get', `$${dst2}`]]],
+                ['local.get', `$${srcOff2}`],
+                ['local.get', `$${dstOff2}`]],
               ['local.get', `$${dst2}`]]],
             ['else', ['local.get', `$${value}`]]]] , 'f64')
       }
@@ -251,8 +312,8 @@ export default (ctx) => {
     const srcBase = tempI32('cb')
     const body = [
       ['local.set', `$${s}`, asF64(emit(proto))],
-      ['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', n * 8]]],
-      ['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['local.get', `$${s}`]]],
+      ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, n)], ['i32.const', 8]]],
+      ['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]],
     ]
     // Copy all properties from proto
     for (let i = 0; i < n; i++)
@@ -268,6 +329,10 @@ function resolveSchema(obj) {
   if (typeof obj === 'string') return ctx.schema.resolve(obj)
   if (Array.isArray(obj) && obj[0] === '{}')
     return obj.slice(1).filter(p => Array.isArray(p) && p[0] === ':').map(p => p[1])
+  // 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
   return null
 }
 
@@ -275,7 +340,16 @@ function resolveSchema(obj) {
  * Emit object literal with spread: {...a, x: 1, ...b, y: 2}
  * Merges schemas from all sources, allocates result, copies in order.
  */
-function emitObjectSpread(props) {
+function takeLiteralTarget() {
+  const frame = ctx.schema.targetStack.at(-1)
+  if (!frame) return null
+  if (typeof frame === 'string') return frame
+  if (!frame.active) return null
+  frame.active = false
+  return frame.name
+}
+
+function emitObjectSpread(props, spreadTarget = takeLiteralTarget()) {
   // Collect merged schema: union of all spread source schemas + explicit props
   const allNames = []
   const addName = n => { if (!allNames.includes(n)) allNames.push(n) }
@@ -299,7 +373,7 @@ function emitObjectSpread(props) {
   const ptr = temp('objp')
   const src = tempI32('osp')
 
-  const body = [['local.set', `$${t}`, ['call', '$__alloc', ['i32.const', schema.length * 8]]]]
+  const body = [['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]]]
 
   // Process props in order — later props override earlier (JS semantics)
   let srcF
@@ -316,13 +390,13 @@ function emitObjectSpread(props) {
         for (let i = 0; i < schema.length; i++) {
           const slot = slotAddr(t, i)
           body.push(['f64.store', slot,
-            ['call', '$__dyn_get_or', ['local.get', `$${srcF}`],
-              emit(['str', String(schema[i])]),
-              ['f64.load', slot]]])
+            ['f64.reinterpret_i64', ['call', '$__dyn_get_or', ['i64.reinterpret_f64', ['local.get', `$${srcF}`]],
+              asI64(emit(['str', String(schema[i])])),
+              ['i64.load', slot]]]])
         }
         continue
       }
-      body.push(['local.set', `$${src}`, ['call', '$__ptr_offset', asF64(emit(p[1]))]])
+      body.push(['local.set', `$${src}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', asF64(emit(p[1]))]]])
       for (let si = 0; si < sSchema.length; si++) {
         const ti = schema.indexOf(sSchema[si])
         if (ti < 0) continue
@@ -335,12 +409,11 @@ function emitObjectSpread(props) {
   }
 
   body.push(['local.set', `$${ptr}`, mkPtrIR(PTR.OBJECT, schemaId, ['local.get', `$${t}`])])
-  const spreadTarget = ctx.schema.targetStack.at(-1)
   if (needsDynShadow(spreadTarget)) {
     inc('__dyn_set')
     for (let i = 0; i < schema.length; i++)
-      body.push(['drop', ['call', '$__dyn_set', ['local.get', `$${ptr}`], emit(['str', String(schema[i])]),
-        ['f64.load', slotAddr(t, i)]]])
+      body.push(['drop', ['call', '$__dyn_set', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], asI64(emit(['str', String(schema[i])])),
+        ['i64.load', slotAddr(t, i)]]])
   }
   body.push(['local.get', `$${ptr}`])
   return typed(['block', ['result', 'f64'], ...body], 'f64')
@@ -355,3 +428,112 @@ function emitStringArray(names) {
   body.push(out.ptr)
   return typed(['block', ['result', 'f64'], ...body], 'f64')
 }
+
+// VAL.HASH covers both literal-typed bindings and JSON-shape inferred chains
+// (e.g. JSON.parse('{...}') → walked via shapeOf for nested `.prop` access).
+// Schema fallback only fires when the static path can't classify the receiver.
+function isHashTyped(obj) {
+  if (typeof obj === 'string') return lookupValType(obj) === VAL.HASH
+  return valTypeOf(obj) === VAL.HASH
+}
+
+// HASH layout: open-addressed probe table, each entry 24 bytes —
+// [hash:f64][key:f64][value:f64]. Slot is empty when hash field == 0
+// (tombstone == 1). __len exposes live entry count at off-8; __cap exposes
+// slot count at off-4. Output array is pre-sized to __len; walk all cap
+// slots and append occupied keys. Iteration order is hash-derived, matching
+// jz's `for-in` over HASH — not the JS spec's insertion order.
+function emitHashKeys(obj) {
+  const t = temp('hk')
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(obj))],
+    hashKeysFromTemp(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
+// a static type guard or a runtime ptr-type check.
+function hashKeysFromTemp(t) {
+  inc('__ptr_offset', '__cap', '__len')
+  const off = tempI32('hko'), cap = tempI32('hkc'), n = tempI32('hkn')
+  const i = tempI32('hki'), o = tempI32('hkj'), slot = tempI32('hks')
+  const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${n}`], tag: 'hka' })
+  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', `$brk${id}`, ['loop', `$loop${id}`,
+      ['br_if', `$brk${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',
+          elemStore(out.local, o,
+            ['f64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 8]]]),
+          ['local.set', `$${o}`, ['i32.add', ['local.get', `$${o}`], ['i32.const', 1]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$loop${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) {
+  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))],
+    ['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', hashKeysFromTemp(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', objectKeysFromTemp(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.
+function objectKeysFromTemp(t) {
+  inc('__alloc_hdr')
+  const sid = tempI32('oks'), src = tempI32('oksrc'), n = tempI32('okn'), out = tempI32('oko'), i = tempI32('oki')
+  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', `$${out}`, ['call', '$__alloc_hdr',
+      ['local.get', `$${n}`], ['local.get', `$${n}`], ['i32.const', 8]]],
+    ['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}`]]],
+      ['i64.store',
+        ['i32.add', ['local.get', `$${out}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]],
+        ['i64.load',
+          ['i32.add', ['local.get', `$${src}`], ['i32.shl', ['local.get', `$${i}`], ['i32.const', 3]]]]],
+      ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+      ['br', `$kloop${id}`]]],
+    mkPtrIR(PTR.ARRAY, 0, ['local.get', `$${out}`])]
+}

package/module/regex.js

@@ -7,8 +7,9 @@
  * @module regex
  */
 
-import { emit, typed, asF64, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/compile.js'
-import { err, inc, PTR } from '../src/ctx.js'
+import { typed, asF64, asI64, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { err, inc, PTR, LAYOUT } from '../src/ctx.js'
 
 // Build IR that constructs a match array: [full, cap1, cap2, ...]
 // strLocal, msLocal, meLocal are local names (i32 for ms/me, f64 for str).
@@ -22,7 +23,7 @@ const buildMatchArr = (strLocal, msLocal, meLocal, nGroups) => {
     ['i32.store', ['local.get', `$${arr}`], ['i32.const', N]],
     ['i32.store', ['i32.add', ['local.get', `$${arr}`], ['i32.const', 4]], ['i32.const', N]],
     ['f64.store', ['i32.add', ['local.get', `$${arr}`], ['i32.const', 8]],
-      ['call', '$__str_slice', ['local.get', `$${strLocal}`],
+      ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${strLocal}`]],
         ['local.get', `$${msLocal}`], ['local.get', `$${meLocal}`]]],
   ]
   for (let i = 1; i <= nGroups; i++) {
@@ -30,7 +31,7 @@ const buildMatchArr = (strLocal, msLocal, meLocal, nGroups) => {
       ['if', ['result', 'f64'],
         ['i32.lt_s', ['global.get', `$__re_g${i}_start`], ['i32.const', 0]],
         ['then', ['f64.const', `nan:${UNDEF_NAN}`]],
-        ['else', ['call', '$__str_slice', ['local.get', `$${strLocal}`],
+        ['else', ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${strLocal}`]],
           ['global.get', `$__re_g${i}_start`], ['global.get', `$__re_g${i}_end`]]]]])
   }
   stmts.push(mkPtrIR(PTR.ARRAY, 0, ['i32.add', ['local.get', `$${arr}`], ['i32.const', 8]]))
@@ -653,14 +654,16 @@ export default (ctx) => {
 
   ctx.runtime.regex = { count: 0, vars: new Map(), compiled: new Map(), groups: new Map() }
 
-  // SSO → heap normalizer: returns data offset (i32) for direct byte access
-  ctx.core.stdlib['__str_to_buf'] = `(func $__str_to_buf (param $ptr f64) (result i32)
-    (local $type i32) (local $off i32) (local $len i32) (local $buf i32) (local $i i32)
-    (local.set $type (call $__ptr_type (local.get $ptr)))
-    (if (i32.eq (local.get $type) (i32.const 4))
+  // SSO → heap normalizer: returns data offset (i32) for direct byte access.
+  // Heap STRING: aux bit SSO_BIT is 0 → offset already points at bytes.
+  // SSO STRING:  aux bit SSO_BIT is 1 → bytes are packed in offset; spill to heap.
+  ctx.core.stdlib['__str_to_buf'] = `(func $__str_to_buf (param $ptr i64) (result i32)
+    (local $aux i32) (local $off i32) (local $len i32) (local $buf i32) (local $i i32)
+    (local.set $aux (call $__ptr_aux (local.get $ptr)))
+    (if (i32.eqz (i32.and (local.get $aux) (i32.const ${LAYOUT.SSO_BIT})))
       (then (return (call $__ptr_offset (local.get $ptr)))))
     (local.set $off (call $__ptr_offset (local.get $ptr)))
-    (local.set $len (call $__ptr_aux (local.get $ptr)))
+    (local.set $len (i32.and (local.get $aux) (i32.const 7)))
     (local.set $buf (call $__alloc (local.get $len)))
     (local.set $i (i32.const 0))
     (block $done (loop $next
@@ -690,7 +693,7 @@ export default (ctx) => {
 
     // Search wrapper: tries match at each position, returns (match_start, match_end) via locals
     const searchName = `__regex_search_${id}`
-    ctx.core.stdlib[searchName] = `(func $${searchName} (param $str f64) (result i32 i32)
+    ctx.core.stdlib[searchName] = `(func $${searchName} (param $str i64) (result i32 i32)
       (local $off i32) (local $len i32) (local $pos i32) (local $result i32)
       (local.set $off (call $__str_to_buf (local.get $str)))
       (local.set $len (call $__str_byteLen (local.get $str)))
@@ -734,7 +737,7 @@ export default (ctx) => {
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${s}`, asF64(emit(str))],
       ['local.set', `$${mstart}`, ['local.set', `$${mend}`,
-        ['call', `$__regex_search_${id}`, ['local.get', `$${s}`]]]],
+        ['call', `$__regex_search_${id}`, ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]],
       // search returns (start, end) multi-value; capture both
       ['if', ['result', 'f64'], ['i32.ge_s', ['local.get', `$${mstart}`], ['i32.const', 0]],
         ['then', ['f64.const', 1]],
@@ -750,7 +753,7 @@ export default (ctx) => {
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${s}`, asF64(emit(str))],
       ['local.set', `$${ms}`, ['local.set', `$${me}`,
-        ['call', `$__regex_search_${id}`, ['local.get', `$${s}`]]]],
+        ['call', `$__regex_search_${id}`, ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]],
       ['if', ['result', 'f64'], ['i32.lt_s', ['local.get', `$${ms}`], ['i32.const', 0]],
         ['then', ['f64.const', 0]],
         ['else', buildMatchArr(s, ms, me, nGroups)]]], 'f64')
@@ -762,13 +765,13 @@ export default (ctx) => {
     if (id == null) {
       // Fall back to string search (indexOf)
       inc('__str_indexof')
-      return typed(['f64.convert_i32_s', ['call', '$__str_indexof', asF64(emit(str)), asF64(emit(search))]], 'f64')
+      return typed(['f64.convert_i32_s', ['call', '$__str_indexof', asI64(emit(str)), asI64(emit(search)), ['i32.const', 0]]], 'f64')
     }
     const s = temp('ss'), ms = tempI32('ssms'), me = tempI32('ssme')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${s}`, asF64(emit(str))],
       ['local.set', `$${ms}`, ['local.set', `$${me}`,
-        ['call', `$__regex_search_${id}`, ['local.get', `$${s}`]]]],
+        ['call', `$__regex_search_${id}`, ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]],
       ['f64.convert_i32_s', ['local.get', `$${ms}`]]], 'f64')
   }
 
@@ -782,21 +785,22 @@ export default (ctx) => {
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${s}`, asF64(emit(str))],
         ['local.set', `$${q}`, asF64(emit(search))],
-        ['local.set', `$${idx}`, ['call', '$__str_indexof', ['local.get', `$${s}`], ['local.get', `$${q}`]]],
+        ['local.set', `$${idx}`, ['call', '$__str_indexof', ['i64.reinterpret_f64', ['local.get', `$${s}`]], ['i64.reinterpret_f64', ['local.get', `$${q}`]], ['i32.const', 0]]],
         ['if', ['result', 'f64'], ['i32.lt_s', ['local.get', `$${idx}`], ['i32.const', 0]],
           ['then', ['f64.const', 0]],
           ['else',
             ['call', '$__wrap1',
-              ['call', '$__str_slice', ['local.get', `$${s}`],
-                ['local.get', `$${idx}`],
-                ['i32.add', ['local.get', `$${idx}`], ['call', '$__str_byteLen', ['local.get', `$${q}`]]]]]]]], 'f64')
+              ['i64.reinterpret_f64',
+                ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${s}`]],
+                  ['local.get', `$${idx}`],
+                  ['i32.add', ['local.get', `$${idx}`], ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${q}`]]]]]]]]]], 'f64')
     }
     const nGroups = ctx.runtime.regex.groups.get(id) || 0
     const s = temp('sm'), ms = tempI32('smms'), me = tempI32('smme')
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${s}`, asF64(emit(str))],
       ['local.set', `$${ms}`, ['local.set', `$${me}`,
-        ['call', `$__regex_search_${id}`, ['local.get', `$${s}`]]]],
+        ['call', `$__regex_search_${id}`, ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]],
       ['if', ['result', 'f64'], ['i32.lt_s', ['local.get', `$${ms}`], ['i32.const', 0]],
         ['then', ['f64.const', 0]],
         ['else', buildMatchArr(s, ms, me, nGroups)]]], 'f64')
@@ -808,7 +812,7 @@ export default (ctx) => {
     if (id == null) {
       // Fall back to string replace
       inc('__str_replace')
-      return typed(['call', '$__str_replace', asF64(emit(str)), asF64(emit(search)), asF64(emit(repl))], 'f64')
+      return typed(['call', '$__str_replace', asI64(emit(str)), asI64(emit(search)), asI64(emit(repl))], 'f64')
     }
     inc('__str_slice', '__str_concat', '__str_byteLen')
     const s = temp('sr'), r = temp('srr'), ms = tempI32('srms'), me = tempI32('srme')
@@ -816,16 +820,16 @@ export default (ctx) => {
       ['local.set', `$${s}`, asF64(emit(str))],
       ['local.set', `$${r}`, asF64(emit(repl))],
       ['local.set', `$${ms}`, ['local.set', `$${me}`,
-        ['call', `$__regex_search_${id}`, ['local.get', `$${s}`]]]],
+        ['call', `$__regex_search_${id}`, ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]],
       ['if', ['result', 'f64'], ['i32.lt_s', ['local.get', `$${ms}`], ['i32.const', 0]],
         ['then', ['local.get', `$${s}`]],
         ['else',
           ['call', '$__str_concat',
-            ['call', '$__str_concat',
-              ['call', '$__str_slice', ['local.get', `$${s}`], ['i32.const', 0], ['local.get', `$${ms}`]],
-              ['local.get', `$${r}`]],
-            ['call', '$__str_slice', ['local.get', `$${s}`], ['local.get', `$${me}`],
-              ['call', '$__str_byteLen', ['local.get', `$${s}`]]]]]]], 'f64')
+            ['i64.reinterpret_f64', ['call', '$__str_concat',
+              ['i64.reinterpret_f64', ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${s}`]], ['i32.const', 0], ['local.get', `$${ms}`]]],
+              ['i64.reinterpret_f64', ['local.get', `$${r}`]]]],
+            ['i64.reinterpret_f64', ['call', '$__str_slice', ['i64.reinterpret_f64', ['local.get', `$${s}`]], ['local.get', `$${me}`],
+              ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]]]]]]], 'f64')
   }
 
   // str.split(/re/) → array of substrings
@@ -834,14 +838,14 @@ export default (ctx) => {
     if (id == null) {
       // Fall back to string split
       inc('__str_split')
-      return typed(['call', '$__str_split', asF64(emit(str)), asF64(emit(sep))], 'f64')
+      return typed(['call', '$__str_split', asI64(emit(str)), asI64(emit(sep))], 'f64')
     }
 
     // Generate a split-by-regex WAT function for this regex
     const splitName = `__regex_split_${id}`
     if (!ctx.core.stdlib[splitName]) {
       inc('__str_to_buf', '__str_slice', '__alloc')
-      ctx.core.stdlib[splitName] = `(func $${splitName} (param $str f64) (result f64)
+      ctx.core.stdlib[splitName] = `(func $${splitName} (param $str i64) (result f64)
         (local $off i32) (local $len i32) (local $pos i32) (local $result i32)
         (local $mstart i32) (local $mend i32) (local $prevEnd i32)
         (local $arrOff i32) (local $count i32) (local $cap i32)
@@ -908,6 +912,6 @@ export default (ctx) => {
       inc(splitName)
     }
 
-    return typed(['call', `$${splitName}`, asF64(emit(str))], 'f64')
+    return typed(['call', `$${splitName}`, asI64(emit(str))], 'f64')
   }
 }