jz 0.3.1 → 0.5.0

package/module/collection.js

@@ -11,6 +11,7 @@
 import { typed, asF64, asI64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64, allocPtr, undefExpr } from '../src/ir.js'
 import { emit, emitFlat } from '../src/emit.js'
 import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
+import { hasOwnContinue } from '../src/analyze.js'
 import { inc, PTR, LAYOUT } from '../src/ctx.js'
 
 const SET_ENTRY = 16  // hash + key
@@ -93,19 +94,20 @@ function genUpsert(name, entrySize, hashFn, eqExpr, expectedType, hasVal, hasExt
 }
 
 /** Generate lookup probe function.
- *  wantValue=true: return slot value, missing => NULL_NAN sentinel.
+ *  wantValue=true: return slot value, missing => `undefined` (UNDEF_NAN) — a
+ *    missing Map entry / object property reads as `undefined` in JS, never null.
  *  wantValue=false: return i32 0/1 existence flag.
  *  hasExt: emit EXTERNAL fallthrough (delegate to __ext_prop/__ext_has). */
 function genLookup(name, entrySize, hashFn, eqExpr, expectedType, wantValue, hasExt) {
   const rt = wantValue ? 'i64' : 'i32'
   const onEmpty = wantValue
-    ? `(return (i64.const ${NULL_NAN}))`
+    ? `(return (i64.const ${UNDEF_NAN}))`
     : '(return (i32.const 0))'
   const onFound = wantValue
     ? '(return (i64.load (i32.add (local.get $slot) (i32.const 16))))'
     : '(return (i32.const 1))'
   const notFound = wantValue
-    ? `(i64.const ${NULL_NAN})`
+    ? `(i64.const ${UNDEF_NAN})`
     : '(i32.const 0)'
   const tExpr = `(i32.wrap_i64 (i64.and (i64.shr_u (local.get $coll) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))`
   const typeGuard = hasExt
@@ -186,7 +188,7 @@ function genUpsertGrow(name, entrySize, hashFn, eqExpr, typeConst, strict = fals
     (if (i32.ge_s (i32.mul (local.get $size) (i32.const 4)) (i32.mul (local.get $cap) (i32.const 3)))
       (then
         (local.set $newcap (i32.shl (local.get $cap) (i32.const 1)))
-        (local.set $newptr (call $__alloc_hdr (i32.const 0) (local.get $newcap) (i32.const ${entrySize})))
+        (local.set $newptr (call $__alloc_hdr_n (i32.const 0) (local.get $newcap) (i32.const ${entrySize})))
         (local.set $i (i32.const 0))
         (block $rd (loop $rl
           (br_if $rd (i32.ge_s (local.get $i) (local.get $cap)))
@@ -335,14 +337,14 @@ export default (ctx) => {
     __hash_has: () => ctx.features.external
       ? ['__str_hash', '__str_eq', '__ptr_type', '__ext_has']
       : ['__str_hash', '__str_eq', '__ptr_type'],
-    __hash_new: ['__alloc_hdr'],
-    __hash_new_small: ['__alloc_hdr', '__mkptr'],
+    __hash_new: ['__alloc_hdr_n'],
+    __hash_new_small: ['__alloc_hdr_n', '__mkptr'],
     __hash_get_local: ['__str_hash', '__str_eq'],
     __hash_get_local_h: ['__str_eq'],
     __hash_set_local_h: ['__str_eq'],
-    __hash_set_local: ['__str_hash', '__str_eq'],
+    __hash_set_local: ['__str_hash', '__str_eq', '__alloc_hdr_n', '__mkptr'],
     __ihash_get_local: ['__map_hash'],
-    __ihash_set_local: ['__map_hash', '__alloc_hdr', '__mkptr'],
+    __ihash_set_local: ['__map_hash', '__alloc_hdr_n', '__mkptr'],
     __dyn_get_t: ['__dyn_get_t_h', '__str_hash'],
     __dyn_get_t_h: ['__ihash_get_local', '__str_eq', '__is_nullish'],
     __dyn_get: ['__dyn_get_t', '__ptr_type'],
@@ -353,9 +355,15 @@ export default (ctx) => {
     __dyn_get_any_t: () => ctx.features.external
       ? ['__dyn_get_t', '__hash_get_local', '__ext_prop']
       : ['__dyn_get_t', '__hash_get_local'],
+    __dyn_get_any_t_h: () => ctx.features.external
+      ? ['__dyn_get_t_h', '__hash_get_local_h', '__ext_prop']
+      : ['__dyn_get_t_h', '__hash_get_local_h'],
     __dyn_get_or: ['__dyn_get'],
     __dyn_set: ['__hash_new', '__hash_new_small', '__ihash_get_local', '__ihash_set_local', '__hash_set_local', '__ptr_offset', '__is_nullish', '__str_eq'],
     __dyn_move: ['__ihash_get_local', '__ihash_set_local', '__is_nullish'],
+    __hash_del_local: ['__str_hash', '__str_eq', '__ptr_type'],
+    __dyn_del: ['__hash_del_local', '__ihash_get_local', '__is_nullish'],
+    __coll_clear: ['__ptr_type', '__ptr_offset'],
   })
 
   inc('__ptr_offset', '__cap')
@@ -437,14 +445,57 @@ export default (ctx) => {
   // __map_new() → f64 — allocate empty Map (for JSON.parse, runtime creation)
   ctx.core.stdlib['__map_new'] = `(func $__map_new (result f64)
     (call $__mkptr (i32.const ${PTR.MAP}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
 
   // === Set ===
 
-  ctx.core.emit['new.Set'] = () => {
+  ctx.core.emit['new.Set'] = (iterExpr) => {
     ctx.features.set = true
-    const out = allocPtr({ type: PTR.SET, len: 0, cap: INIT_CAP, stride: SET_ENTRY, tag: 'set' })
-    return typed(['block', ['result', 'f64'], out.init, out.ptr], 'f64')
+    if (iterExpr == null) {
+      const out = allocPtr({ type: PTR.SET, len: 0, cap: INIT_CAP, stride: SET_ENTRY, tag: 'set' })
+      return typed(['block', ['result', 'f64'], out.init, out.ptr], 'f64')
+    }
+    // new Set(iterable): seed from an array argument's elements. __set_add does
+    // SameValueZero dedup + −0 normalization. A non-array argument leaves the set
+    // empty — the ptr_type guard zeroes the length so the loop is skipped.
+    //
+    // __set_add is a FIXED-capacity probe (genUpsert never grows the table); a
+    // full table makes its probe loop spin forever. So the table is pre-sized to
+    // the smallest power of two greater than 2*len: distinct entries ≤ len, so the
+    // table stays ≤50% full and every insert finds a free slot. cap = 1 <<
+    // (32 − clz(m−1)) with m = 2*len + INIT_CAP rounds 2*len up to a power of two
+    // and floors at INIT_CAP for the empty/short case.
+    inc('__set_add', '__ptr_type', '__len', '__typed_idx')
+    const setL = temp('nss'), arrL = temp('nsa')
+    const iL = tempI32('nsi'), lenL = tempI32('nsl')
+    const capExpr = ['i32.shl', ['i32.const', 1],
+      ['i32.sub', ['i32.const', 32], ['i32.clz',
+        ['i32.sub',
+          ['i32.add', ['i32.shl', ['local.get', `$${lenL}`], ['i32.const', 1]], ['i32.const', INIT_CAP]],
+          ['i32.const', 1]]]]]
+    const out = allocPtr({ type: PTR.SET, len: 0, cap: capExpr, stride: SET_ENTRY, tag: 'set' })
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${arrL}`, asF64(emit(iterExpr))],
+      ['local.set', `$${lenL}`, ['i32.const', 0]],
+      ['if', ['i32.eq',
+          ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]],
+          ['i32.const', PTR.ARRAY]],
+        ['then', ['local.set', `$${lenL}`,
+          ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]]]]],
+      out.init,
+      ['local.set', `$${setL}`, out.ptr],
+      ['local.set', `$${iL}`, ['i32.const', 0]],
+      ['block', `$d_${iL}`, ['loop', `$l_${iL}`,
+        ['br_if', `$d_${iL}`, ['i32.ge_s', ['local.get', `$${iL}`], ['local.get', `$${lenL}`]]],
+        ['local.set', `$${setL}`, ['f64.reinterpret_i64',
+          ['call', '$__set_add',
+            ['i64.reinterpret_f64', ['local.get', `$${setL}`]],
+            ['i64.reinterpret_f64', ['call', '$__typed_idx',
+              ['i64.reinterpret_f64', ['local.get', `$${arrL}`]],
+              ['local.get', `$${iL}`]]]]]],
+        ['local.set', `$${iL}`, ['i32.add', ['local.get', `$${iL}`], ['i32.const', 1]]],
+        ['br', `$l_${iL}`]]],
+      ['local.get', `$${setL}`]], 'f64')
   }
 
   ctx.core.emit['.add'] = (setExpr, val) => {
@@ -462,10 +513,55 @@ export default (ctx) => {
     return typed(['f64.convert_i32_s', ['call', '$__set_delete', asI64(emit(setExpr)), asI64(emit(val))]], 'f64')
   }
 
+  // Map.prototype.clear / Set.prototype.clear — drop every entry. `.clear` only
+  // exists on Map/Set in JS, so a single generic emitter is unambiguous; the
+  // stdlib reads the ptr tag to pick the entry stride.
+  ctx.core.emit['.clear'] = (collExpr) => {
+    inc('__coll_clear')
+    return typed(['call', '$__coll_clear', asI64(emit(collExpr))], 'f64')
+  }
+
+  // Zero every slot (so probes see empty) and reset the length header. Entry
+  // stride is 16 for a SET, 24 for a MAP — `(t == MAP) << 3` adds the 8-byte
+  // value column. Returns undefined; a non-collation arg is a guarded no-op.
+  ctx.core.stdlib['__coll_clear'] = `(func $__coll_clear (param $coll i64) (result f64)
+    (local $off i32) (local $cap i32) (local $t i32)
+    (local.set $t (call $__ptr_type (local.get $coll)))
+    (if (i32.or (i32.eq (local.get $t) (i32.const ${PTR.SET})) (i32.eq (local.get $t) (i32.const ${PTR.MAP})))
+      (then
+        (local.set $off (call $__ptr_offset (local.get $coll)))
+        (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
+        (memory.fill (local.get $off) (i32.const 0)
+          (i32.mul (local.get $cap)
+            (i32.add (i32.const ${SET_ENTRY})
+              (i32.shl (i32.eq (local.get $t) (i32.const ${PTR.MAP})) (i32.const 3)))))
+        (i32.store (i32.sub (local.get $off) (i32.const 8)) (i32.const 0))))
+    (f64.reinterpret_i64 (i64.const ${UNDEF_NAN})))`
+
   ctx.core.emit['.size'] = (expr) => {
     return typed(['f64.convert_i32_s', ['call', '$__len', ['i64.reinterpret_f64', asF64(emit(expr))]]], 'f64')
   }
 
+  // x instanceof Map / Set — typed-pointer predicates emitted by jzify. NaN-check
+  // first (non-pointer numbers must report false), then compare __ptr_type tag.
+  // Mirrors module/array.js's Array.isArray inline form. Result is i32 (boolean).
+  ctx.core.emit['__is_map'] = (x) => {
+    inc('__ptr_type')
+    const v = asF64(emit(x))
+    const t = temp('imap')
+    return typed(['i32.and',
+      ['f64.ne', ['local.tee', `$${t}`, v], ['local.get', `$${t}`]],
+      ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.MAP]]], 'i32')
+  }
+  ctx.core.emit['__is_set'] = (x) => {
+    inc('__ptr_type')
+    const v = asF64(emit(x))
+    const t = temp('iset')
+    return typed(['i32.and',
+      ['f64.ne', ['local.tee', `$${t}`, v], ['local.get', `$${t}`]],
+      ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.SET]]], 'i32')
+  }
+
   // Generated Set probe functions
   ctx.core.stdlib['__set_add'] = () => genUpsert('__set_add', SET_ENTRY, '$__map_hash', sameValueZeroEq, PTR.SET, false, ctx.features.external)
   ctx.core.stdlib['__set_has'] = () => genLookup('__set_has', SET_ENTRY, '$__map_hash', sameValueZeroEq, PTR.SET, false, ctx.features.external)
@@ -512,7 +608,7 @@ export default (ctx) => {
   // Generated Map probe functions
   ctx.core.stdlib['__map_set'] = () => genUpsert('__map_set', MAP_ENTRY, '$__map_hash', sameValueZeroEq, PTR.MAP, true, ctx.features.external)
   ctx.core.stdlib['__map_get'] = () => genLookup('__map_get', MAP_ENTRY, '$__map_hash', sameValueZeroEq, PTR.MAP, true, ctx.features.external)
-  ctx.core.stdlib['__map_get_h'] = () => genLookupStrictPrehashed('__map_get_h', MAP_ENTRY, sameValueZeroEq, PTR.MAP, NULL_NAN, ctx.features.external)
+  ctx.core.stdlib['__map_get_h'] = () => genLookupStrictPrehashed('__map_get_h', MAP_ENTRY, sameValueZeroEq, PTR.MAP, UNDEF_NAN, ctx.features.external)
   ctx.core.stdlib['__map_has'] = () => genLookup('__map_has', MAP_ENTRY, '$__map_hash', sameValueZeroEq, PTR.MAP, false, ctx.features.external)
   ctx.core.stdlib['__map_delete'] = genDelete('__map_delete', MAP_ENTRY, '$__map_hash', sameValueZeroEq, PTR.MAP)
 
@@ -567,19 +663,25 @@ export default (ctx) => {
 
   ctx.core.stdlib['__hash_new'] = `(func $__hash_new (result f64)
     (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
 
   // Small initial capacity for propsPtr-style hashes (per-object dyn props).
   // Most receivers in real code carry 0-2 dyn props; paying 8-slot up-front
   // is wasted memory + probe-loop cache pressure. Grows to 4/8/... on demand.
+  // L3/'speed' opts into a larger initial cap (default 8) to skip 2→4→8 growth
+  // when AST-style nodes carry 3-5 props (watr.compile's profile).
+  const smallCap = Math.max(ctx.transform.optimize?.hashSmallInitCap | 0, 2)
   ctx.core.stdlib['__hash_new_small'] = `(func $__hash_new_small (result f64)
     (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const 2) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${smallCap}) (i32.const ${MAP_ENTRY}))))`
 
   ctx.core.stdlib['__hash_get_local'] = genLookupStrict('__hash_get_local', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH)
   ctx.core.stdlib['__hash_get_local_h'] = genLookupStrictPrehashed('__hash_get_local_h', MAP_ENTRY, strEq, PTR.HASH)
   ctx.core.stdlib['__hash_set_local_h'] = genUpsertStrictPrehashed('__hash_set_local_h', MAP_ENTRY, strEq, PTR.HASH)
   ctx.core.stdlib['__hash_set_local'] = genUpsertGrow('__hash_set_local', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH, true)
+  // Tombstones an entry in a HASH (string keys). Returns 1 if found+deleted, 0 otherwise.
+  // Used as the bucket-level primitive for __dyn_del.
+  ctx.core.stdlib['__hash_del_local'] = genDelete('__hash_del_local', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH)
   // Outer __dyn_props hash: keyed by object offset (i32 as f64 bits), value is per-object props hash.
   // Uses bit-hash + i64.eq — no string allocation for the unique integer key.
   ctx.core.stdlib['__ihash_get_local'] = genLookupStrict('__ihash_get_local', MAP_ENTRY, '$__map_hash', '(i64.eq (i64.load (i32.add (local.get $slot) (i32.const 8))) (local.get $key))', PTR.HASH)
@@ -709,6 +811,11 @@ export default (ctx) => {
             (br_if $haveProps (i32.eq
               (i32.wrap_i64 (i64.and (i64.shr_u (local.get $props) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
               (i32.const ${PTR.HASH})))
+            ;; Fresh array (header propsPtr=0, no shift, no props): skip the
+            ;; global hash probe — there's nothing to find. Shifted arrays read
+            ;; forwarding bytes here (low32=newOff, high32=-1) → non-zero, so
+            ;; this br_if doesn't fire and they fall through to __dyn_props.
+            (br_if $dynDone (i64.eqz (local.get $props)))
             (local.set $props (i64.const 0))))
         ;; OBJECT: heap-allocated (off >= __heap_start) carries propsPtr at
         ;; off-16 from __alloc_hdr. The slot is either 0 (no dyn props yet) or
@@ -829,6 +936,28 @@ export default (ctx) => {
           (else ${extArm})))))`
   }
 
+  // Prehashed variant of __dyn_get_any_t for constant string keys: the FNV hash
+  // is folded at compile time (strHashLiteral), so no __str_hash call at runtime.
+  // Hot for the layered-parser pattern — `parse.step`/`parse.space`/… reads a
+  // function-object property with a literal key on every parser step.
+  ctx.core.stdlib['__dyn_get_any_t_h'] = () => {
+    const extArm = ctx.features.external
+      ? `(if (result i64) (i32.eq (local.get $t) (i32.const ${PTR.EXTERNAL}))
+            (then (call $__ext_prop (local.get $obj) (local.get $key)))
+            (else (i64.const ${NULL_NAN})))`
+      : `(i64.const ${NULL_NAN})`
+    return `(func $__dyn_get_any_t_h (param $obj i64) (param $key i64) (param $t i32) (param $h i32) (result i64)
+    (local $val i64)
+    (if (result i64) (i32.eq (local.get $t) (i32.const ${PTR.HASH}))
+      (then (call $__hash_get_local_h (local.get $obj) (local.get $key) (local.get $h)))
+      (else
+        (local.set $val (call $__dyn_get_t_h (local.get $obj) (local.get $key) (local.get $t) (local.get $h)))
+        (if (result i64)
+          (i64.ne (local.get $val) (i64.const ${UNDEF_NAN}))
+          (then (local.get $val))
+          (else ${extArm})))))`
+  }
+
   // Hot for `node.loc = pos` patterns (e.g. watr's parser tags every nested level).
   // Defer the root insert to the end and gate it on props-ptr change: most calls hit
   // the no-grow case where the ptr is unchanged and the root slot already points to it.
@@ -925,6 +1054,91 @@ export default (ctx) => {
           (then (global.set $__dyn_get_cache_props (f64.reinterpret_i64 (local.get $props)))))))
     (local.get $val))`
 
+  // Tag-dispatched delete (mirrors __dyn_set's dispatch). Returns 1 if a slot was
+  // found+tombstoned, 0 otherwise. Header types (ARRAY non-shifted, OBJECT heap-only,
+  // TYPED/HASH/SET/MAP) carry propsPtr at off-16; others fall back to the global
+  // __dyn_props hash keyed by offset.
+  // Schema-aware delete arm: when the receiver is an OBJECT with a known schema and
+  // the key matches a static slot, overwrite that slot with UNDEF_NAN so subsequent
+  // reads see "absent" (matches `delete obj.a; obj.a → undefined`). Without this,
+  // the shadow-store delete alone would leave the structural slot intact and a later
+  // ctx[k] read would re-surface the original value.
+  const buildObjectSchemaDelArm = () => (ctx.schema.list.length > 0 || ctx.core.includes.has('__jp_obj')) ? `
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.OBJECT}))
+                 (i32.ne (global.get $__schema_tbl) (i32.const 0)))
+      (then
+        (local.set $sid (i32.wrap_i64 (i64.and (i64.shr_u
+          (local.get $obj) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK}))))
+        (local.set $kbits
+          (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3)))))
+        (local.set $koff (i32.wrap_i64 (i64.and (local.get $kbits) (i64.const ${LAYOUT.OFFSET_MASK}))))
+        (local.set $nkeys (i32.load (i32.sub (local.get $koff) (i32.const 8))))
+        (local.set $idx (i32.const 0))
+        (block $schemaDelDone (loop $schemaDelLoop
+          (br_if $schemaDelDone (i32.ge_s (local.get $idx) (local.get $nkeys)))
+          (if (call $__str_eq
+                (i64.load (i32.add (local.get $koff) (i32.shl (local.get $idx) (i32.const 3))))
+                (local.get $key))
+            (then
+              (i64.store (i32.add (local.get $off) (i32.shl (local.get $idx) (i32.const 3))) (i64.const ${UNDEF_NAN}))
+              (local.set $hit (i32.const 1))
+              (br $schemaDelDone)))
+          (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+          (br $schemaDelLoop)))))` : ''
+
+  ctx.core.stdlib['__dyn_del'] = () => `(func $__dyn_del (param $obj i64) (param $key i64) (result i32)
+    (local $root i64) (local $props i64) (local $oldProps i64)
+    (local $off i32) (local $type i32) (local $hit i32) ${buildObjectSchemaSetLocals()}
+    (local.set $off (i32.wrap_i64 (i64.and (local.get $obj) (i64.const ${LAYOUT.OFFSET_MASK}))))
+    (local.set $type (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK}))))
+    ${buildObjectSchemaDelArm()}
+    ;; CLOSURE with no env: rekey to function table index (parallels __dyn_set / __dyn_get_t_h).
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.CLOSURE})) (i32.eqz (local.get $off)))
+      (then (local.set $off (i32.sub (i32.const -1)
+        (i32.wrap_i64 (i64.and (i64.shr_u (local.get $obj) (i64.const ${LAYOUT.AUX_SHIFT})) (i64.const ${LAYOUT.AUX_MASK})))))))
+    ;; ARRAY: follow forwarding chain to landed base.
+    (if (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
+      (then
+        (block $done
+          (loop $follow
+            (br_if $done (i32.lt_u (local.get $off) (i32.const 16)))
+            (br_if $done (i32.gt_u (local.get $off) (i32.shl (memory.size) (i32.const 16))))
+            (br_if $done (i32.ne (i32.load (i32.sub (local.get $off) (i32.const 4))) (i32.const -1)))
+            (local.set $off (i32.load (i32.sub (local.get $off) (i32.const 8))))
+            (br $follow)))))
+    ;; ARRAY landed propsPtr (HASH-tagged means real sidecar; else fall through to global).
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.ARRAY}))
+                 (i32.ge_u (local.get $off) (i32.const 16)))
+      (then
+        (local.set $oldProps (i64.load (i32.sub (local.get $off) (i32.const 16))))
+        (if (i32.eq
+              (i32.wrap_i64 (i64.and (i64.shr_u (local.get $oldProps) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
+              (i32.const ${PTR.HASH}))
+          (then (return (i32.or (local.get $hit) (call $__hash_del_local (local.get $oldProps) (local.get $key))))))))
+    ;; OBJECT heap: propsPtr directly at off-16.
+    (if (i32.and (i32.eq (local.get $type) (i32.const ${PTR.OBJECT}))
+                 (i32.ge_u (local.get $off) (global.get $__heap_start)))
+      (then
+        (local.set $oldProps (i64.load (i32.sub (local.get $off) (i32.const 16))))
+        (if (i64.eqz (local.get $oldProps)) (then (return (local.get $hit))))
+        (return (i32.or (local.get $hit) (call $__hash_del_local (local.get $oldProps) (local.get $key))))))
+    ;; Other header types (TYPED/HASH/SET/MAP).
+    (if (i32.and (i32.ge_u (local.get $off) (i32.const 16))
+          (i32.or (i32.eq (local.get $type) (i32.const ${PTR.TYPED}))
+            (i32.or (i32.eq (local.get $type) (i32.const ${PTR.HASH}))
+              (i32.or (i32.eq (local.get $type) (i32.const ${PTR.SET}))
+                      (i32.eq (local.get $type) (i32.const ${PTR.MAP}))))))
+      (then
+        (local.set $oldProps (i64.load (i32.sub (local.get $off) (i32.const 16))))
+        (if (i64.eqz (local.get $oldProps)) (then (return (local.get $hit))))
+        (return (i32.or (local.get $hit) (call $__hash_del_local (local.get $oldProps) (local.get $key))))))
+    ;; Fallback: global __dyn_props keyed by offset.
+    (local.set $root (i64.reinterpret_f64 (global.get $__dyn_props)))
+    (if (i64.eqz (local.get $root)) (then (return (local.get $hit))))
+    (local.set $props (call $__ihash_get_local (local.get $root) (i64.reinterpret_f64 (f64.convert_i32_s (local.get $off)))))
+    (if (call $__is_nullish (local.get $props)) (then (return (local.get $hit))))
+    (i32.or (local.get $hit) (call $__hash_del_local (local.get $props) (local.get $key))))`
+
   ctx.core.stdlib['__dyn_move'] = `(func $__dyn_move (param $oldOff i32) (param $newOff i32)
     (local $props i64) (local $root i64)
     (if (f64.eq (global.get $__dyn_props) (f64.const 0)) (then (return)))
@@ -938,6 +1152,15 @@ export default (ctx) => {
   ctx.core.stdlib['__hash_get'] = () => genLookup('__hash_get', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH, true, ctx.features.external)
   ctx.core.stdlib['__hash_has'] = () => genLookup('__hash_has', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH, false, ctx.features.external)
 
+  // === `delete obj[k]`: lift from prepare for computed-key removal ===
+  // Static-key `delete obj.x` / `delete obj["x"]` is rejected in prepare (fixed schema);
+  // only the runtime-dispatched form reaches here. JS returns `true` on success — we
+  // surface the actual found/not-found bit as i32 (`true`/`false` ↔ 1/0 in jz NaN-box).
+  ctx.core.emit['delete'] = (obj, key) => {
+    inc('__dyn_del')
+    return typed(['call', '$__dyn_del', asI64(emit(obj)), asI64(emit(key))], 'i32')
+  }
+
   // === `in` operator: key in obj → HASH key existence check ===
   ctx.core.emit['in'] = (key, obj) => {
     const objType = typeof obj === 'string' ? lookupValType(obj) : valTypeOf(obj)
@@ -1032,8 +1255,14 @@ export default (ctx) => {
     const ptrI64 = tempI64('hp'), srcOff = tempI32('hso'), srcType = tempI32('hst')
     if (!ctx.func.locals.has(varName)) ctx.func.locals.set(varName, 'f64')
     const id = ctx.func.uniq++
+    const brk = `$brk${id}`, loop = `$loop${id}`, cont = `$cont${id}`
     const va = asF64(emit(src))
-    const bodyFlat = emitFlat(body)
+    const needsCont = hasOwnContinue(body)
+    ctx.func.stack.push({ brk, loop: needsCont ? cont : loop })
+    let bodyFlat
+    try { bodyFlat = emitFlat(body) }
+    finally { ctx.func.stack.pop() }
+    const bodyBlock = needsCont ? [['block', cont, ...bodyFlat]] : bodyFlat
     inc('__ptr_type')
     return [
       // Save source ptr as i64
@@ -1054,16 +1283,16 @@ export default (ctx) => {
           ['local.set', `$${off}`, ['call', '$__ptr_offset', ['local.get', `$${ptrI64}`]]],
           ['local.set', `$${cap}`, ['call', '$__cap', ['local.get', `$${ptrI64}`]]],
           ['local.set', `$${i}`, ['i32.const', 0]],
-          ['block', `$brk${id}`, ['loop', `$loop${id}`,
-            ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+          ['block', brk, ['loop', loop,
+            ['br_if', brk, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
             ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
               ['i32.mul', ['local.get', `$${i}`], ['i32.const', MAP_ENTRY]]]],
             ['if', ['i64.ne', ['i64.load', ['local.get', `$${slot}`]], ['i64.const', 0]],
               ['then',
                 ['local.set', `$${varName}`, ['f64.reinterpret_i64', ['i64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 8]]]]],
-                ...bodyFlat]],
+                ...bodyBlock]],
             ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
-            ['br', `$loop${id}`]]]]]
+            ['br', loop]]]]]
     ]
   }
 }

package/module/console.js

@@ -2,7 +2,7 @@
  * Console + clocks module — two host-mode lowerings.
  *
  * `host: 'js'` (default): emit `env.print(val: i64, fd: i32, sep: i32)` and
- *   `env.now(clock: i32) -> f64`. The JS host (src/host.js) wires both
+ *   `env.now(clock: i32) -> f64`. The JS host (interop.js) wires both
  *   automatically — `print` reads the NaN-boxed value via `mem.read`, so
  *   stringification happens host-side (no __ftoa / __write_str / __write_val
  *   stdlib in the binary). `sep`: 10=newline, 32=space, 0=no separator.