jz 0.9.1 → 0.9.2

package/module/console.js

@@ -194,6 +194,8 @@ const setupWasi = (ctx) => {
   makeConsole('log', 1)
   makeConsole('warn', 2)
   makeConsole('error', 2)
+  makeConsole('info', 1)   // spec/Node: info & debug are log-level -> stdout
+  makeConsole('debug', 1)
 
   const needClock = () => hostImport('wasi_snapshot_preview1', 'clock_time_get',
     ['func', '$__clock_time_get', ['param', 'i32'], ['param', 'i64'], ['param', 'i32'], ['result', 'i32']])
@@ -266,6 +268,8 @@ const setupJsHost = (ctx) => {
   makeConsole('log', 1)
   makeConsole('warn', 2)
   makeConsole('error', 2)
+  makeConsole('info', 1)   // spec/Node: info & debug are log-level -> stdout
+  makeConsole('debug', 1)
 
   reg('Date.now', [], () => {
     needNow()

package/module/core.js

@@ -15,6 +15,7 @@ import { reconstructArgsWithSpreads } from '../src/ir.js'
 import { valTypeOf, shapeOf } from '../src/kind.js'
 import { T } from '../src/ast.js'
 import { inlineArraySid } from '../src/static.js'
+import { packedI32, structInline } from '../src/abi/index.js'
 import { VAL, lookupValType, lookupNotString, repOf, updateRep } from '../src/reps.js'
 import { ctx, err, inc, PTR, LAYOUT, HEAP, FORWARDING_MASK, emitArity, followForwardingWat, declGlobal } from '../src/ctx.js'
 import { ptrOffsetFwdWat, STR_INTERN_BIT } from '../layout.js'
@@ -31,6 +32,7 @@ export default (ctx) => {
     __len: ['__typed_shift', '__ptr_offset', '__ptr_offset_fwd'],
     __cap: ['__typed_shift', '__ptr_type', '__ptr_offset', '__ptr_aux'],
     __typed_data: ['__ptr_offset', '__ptr_aux'],
+    __typed_idx: () => (ctx.features.f16 ? ['__f16_to_f64'] : []),
     __ptr_offset: ['__ptr_offset_fwd'],
     __ptr_offset_fwd: [],
     __is_str_key: ['__ptr_type'],
@@ -233,9 +235,11 @@ export default (ctx) => {
                   (then (f64.convert_i32_u (i32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))
                   (else (f64.convert_i32_s (i32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))))
                 (else (if (result f64) (i32.ge_u (local.get $et) (i32.const 2))
-                  (then (if (result f64) (i32.and (local.get $et) (i32.const 1))
+                  (then ${ctx.features.f16 ? `(if (result f64) (i32.and (local.get $aux) (i32.const 32))
+                    (then (call $__f16_to_f64 (i32.load16_u (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))))))
+                    (else ` : ''}(if (result f64) (i32.and (local.get $et) (i32.const 1))
                     (then (f64.convert_i32_u (i32.load16_u (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))))))
-                    (else (f64.convert_i32_s (i32.load16_s (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1))))))))
+                    (else (f64.convert_i32_s (i32.load16_s (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 1)))))))${ctx.features.f16 ? '))' : ''})
                   (else (if (result f64) (i32.and (local.get $et) (i32.const 1))
                     (then (f64.convert_i32_u (i32.load8_u (i32.add (local.get $off) (local.get $i)))))
                     (else (f64.convert_i32_s (i32.load8_s (i32.add (local.get $off) (local.get $i)))))))))))))
@@ -657,6 +661,74 @@ export default (ctx) => {
       (then (i32.load (i32.add (local.get $off) (i32.const 4))))
       (else (local.get $off))))`
 
+  // === binary16 ↔ f64 (Float16Array / DataView.getFloat16 / Math.f16round) ===
+  // Pure-integer, exactly rounded — f64 → f16 rounds DIRECTLY off the f64 bits
+  // (an f32 hop double-rounds at the overflow boundary: 65519.999… must round
+  // to 65504, not Inf). f16 → f64 is exact by construction (every half is a
+  // double). NaN canonicalizes (sign/payload dropped) so `v !== v` stays sound
+  // on jz's canonical-NaN model.
+  ctx.core.stdlib['__f16_to_f64'] = `(func $__f16_to_f64 (param $b i32) (result f64)
+    (local $h i32) (local $e i32) (local $m i32) (local $r f64)
+    (local.set $h (i32.and (local.get $b) (i32.const 0x7FFF)))
+    (local.set $e (i32.shr_u (local.get $h) (i32.const 10)))
+    (local.set $m (i32.and (local.get $h) (i32.const 0x3FF)))
+    (if (i32.eq (local.get $e) (i32.const 31))
+      (then
+        (if (local.get $m)
+          (then (return (f64.reinterpret_i64 (i64.const ${nanPrefixHex()}))))
+          (else (return (f64.reinterpret_i64 (i64.or (i64.const 0x7FF0000000000000)
+            (i64.shl (i64.extend_i32_u (i32.and (local.get $b) (i32.const 0x8000))) (i64.const 48)))))))))
+    (if (i32.eqz (local.get $e))
+      ;; subnormal: mant · 2^-24 (exact — integer times a power of two)
+      (then (local.set $r (f64.mul (f64.convert_i32_u (local.get $m)) (f64.const 5.960464477539063e-8))))
+      (else (local.set $r (f64.reinterpret_i64 (i64.or
+        (i64.shl (i64.extend_i32_u (i32.add (local.get $e) (i32.const 1008))) (i64.const 52))
+        (i64.shl (i64.extend_i32_u (local.get $m)) (i64.const 42)))))))
+    (f64.reinterpret_i64 (i64.or (i64.reinterpret_f64 (local.get $r))
+      (i64.shl (i64.extend_i32_u (i32.and (local.get $b) (i32.const 0x8000))) (i64.const 48)))))`
+
+  ctx.core.stdlib['__f64_to_f16'] = `(func $__f64_to_f16 (param $v f64) (result i32)
+    (local $u i64) (local $sign i32) (local $ne i32) (local $half i32)
+    (local $m i64) (local $full i64) (local $sh i64) (local $rb i64) (local $hp i64)
+    (local.set $u (i64.reinterpret_f64 (local.get $v)))
+    (local.set $sign (i32.wrap_i64 (i64.and (i64.shr_u (local.get $u) (i64.const 48)) (i64.const 0x8000))))
+    (local.set $u (i64.and (local.get $u) (i64.const 0x7FFFFFFFFFFFFFFF)))
+    (if (i64.ge_u (local.get $u) (i64.const 0x7FF0000000000000))
+      (then (return (i32.or (local.get $sign)
+        (select (i32.const 0x7E00) (i32.const 0x7C00) (i64.gt_u (local.get $u) (i64.const 0x7FF0000000000000)))))))
+    (local.set $m (i64.and (local.get $u) (i64.const 0xFFFFFFFFFFFFF)))
+    (local.set $ne (i32.sub (i32.wrap_i64 (i64.shr_u (local.get $u) (i64.const 52))) (i32.const 1008)))
+    (if (i32.ge_s (local.get $ne) (i32.const 31))
+      (then (return (i32.or (local.get $sign) (i32.const 0x7C00)))))
+    (if (i32.ge_s (local.get $ne) (i32.const 1))
+      (then ;; normal: 42 dropped mantissa bits round ties-to-even; a mantissa
+            ;; carry overflows into the exponent or into infinity — both exact
+        (local.set $half (i32.or (i32.shl (local.get $ne) (i32.const 10))
+          (i32.wrap_i64 (i64.shr_u (local.get $m) (i64.const 42)))))
+        (local.set $rb (i64.and (local.get $m) (i64.const 0x3FFFFFFFFFF)))
+        (if (i32.or (i64.gt_u (local.get $rb) (i64.const 0x20000000000))
+              (i32.and (i64.eq (local.get $rb) (i64.const 0x20000000000)) (i32.and (local.get $half) (i32.const 1))))
+          (then (local.set $half (i32.add (local.get $half) (i32.const 1)))))
+        (return (i32.or (local.get $sign) (local.get $half)))))
+    (if (i32.lt_s (local.get $ne) (i32.const -10))
+      (then (return (local.get $sign)))) ;; underflow → ±0
+    ;; subnormal: shift the 53-bit significand by 43-ne (43…53), ties-to-even
+    (local.set $full (i64.or (local.get $m) (i64.const 0x10000000000000)))
+    (local.set $sh (i64.extend_i32_u (i32.sub (i32.const 43) (local.get $ne))))
+    (local.set $half (i32.wrap_i64 (i64.shr_u (local.get $full) (local.get $sh))))
+    (local.set $rb (i64.and (local.get $full) (i64.sub (i64.shl (i64.const 1) (local.get $sh)) (i64.const 1))))
+    (local.set $hp (i64.shl (i64.const 1) (i64.sub (local.get $sh) (i64.const 1))))
+    (if (i32.or (i64.gt_u (local.get $rb) (local.get $hp))
+          (i32.and (i64.eq (local.get $rb) (local.get $hp)) (i32.and (local.get $half) (i32.const 1))))
+      (then (local.set $half (i32.add (local.get $half) (i32.const 1)))))
+    (i32.or (local.get $sign) (local.get $half)))`
+
+  // ToUint8Clamp (Uint8ClampedArray stores): NaN → 0, clamp [0,255],
+  // round-half-to-even — f64.nearest IS ties-to-even.
+  ctx.core.stdlib['__u8_clamp'] = `(func $__u8_clamp (param $v f64) (result i32)
+    (if (f64.ne (local.get $v) (local.get $v)) (then (return (i32.const 0))))
+    (i32.trunc_sat_f64_u (f64.nearest (f64.min (f64.max (local.get $v) (f64.const 0)) (f64.const 255)))))`
+
   // Hot (~85M calls in watr self-host). Type/offset extraction inlined; forwarding
   // loop only entered for ARRAY. ARRAY fast path dominates (nodes?.length, out.length …).
   ctx.core.stdlib['__len'] = `(func $__len (param $ptr i64) (result i32)
@@ -857,11 +929,13 @@ export default (ctx) => {
       (then
         (local.set $cap (call $__cap (local.get $bits)))
         (local.set $src (call $__ptr_offset (local.get $bits)))
-        (local.set $dst (call $__alloc_hdr_n (i32.const 0) (local.get $cap) (i32.const 24)))
+        ;; 28 = MAP_ENTRY + the probe hash lane (collection.js) — the wholesale
+        ;; copy must carry the lane or the clone's probes see stale zeros
+        (local.set $dst (call $__alloc_hdr_n (i32.const 0) (local.get $cap) (i32.const 28)))
         (memory.copy
           (i32.sub (local.get $dst) (i32.const 16))
           (i32.sub (local.get $src) (i32.const 16))
-          (i32.add (i32.const 16) (i32.mul (local.get $cap) (i32.const 24))))
+          (i32.add (i32.const 16) (i32.mul (local.get $cap) (i32.const 28))))
         (return (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0) (local.get $dst)))))
     (local.get $v))`
 
@@ -951,6 +1025,9 @@ export default (ctx) => {
     const base = (baseExpr?.ptrKind != null && baseExpr.ptrKind !== VAL.ARRAY)
       ? baseExpr
       : (baseExpr?.type === 'f64' ? baseExpr : asF64(baseExpr))
+    // Packed i32 cells (structInline + inlineCellI32, flag rides the cursor
+    // node): the field IS a raw i32 at +idx*4 — one i32.load, no trunc_sat.
+    if (baseExpr?.cellI32) return typed(packedI32.ops.load(ptrOffsetIR(base, VAL.OBJECT), idx), 'i32')
     const load = ctx.abi.object.ops.load(ptrOffsetIR(base, VAL.OBJECT), idx)
     // Strict-int32 slot (ctx.schema.slotI32CertainAt — every censused write is
     // exactly-int32, never -0): land the value directly in i32. trunc_sat of
@@ -1306,13 +1383,15 @@ export default (ctx) => {
       if (Array.isArray(obj) && (obj[0] === 'str' || obj[0] == null) && typeof obj[1] === 'string') {
         return typed(['f64.const', new TextEncoder().encode(obj[1]).length], 'f64')
       }
-      // structInline Array<S>: the header `len` counts physical f64 cells (K
-      // per element), so the JS array length is `physicalLen / K`.
+      // structInline Array<S>: the header `len` counts physical 8-byte cells
+      // (K per element, ⌈K/2⌉ when packed i32), so the JS array length is
+      // `physicalLen / cellsPerElem`.
       const inlSid = inlineArraySid(obj)
       if (inlSid != null) {
         const K = ctx.schema.list[inlSid].length
+        const cpe = structInline(K, ctx.schema.inlineCellI32?.has(inlSid)).cpe
         const physLen = ['i32.load', ['i32.sub', ptrOffsetIR(asF64(emit(obj)), VAL.ARRAY), ['i32.const', 8]]]
-        return typed(['f64.convert_i32_s', K > 1 ? ['i32.div_s', physLen, ['i32.const', K]] : physLen], 'f64')
+        return typed(['f64.convert_i32_s', cpe > 1 ? ['i32.div_s', physLen, ['i32.const', cpe]] : physLen], 'f64')
       }
       const rep = typeof obj === 'string' ? repOf(obj) : null
       const vt = rep ? rep.val : valTypeOf(obj)

package/module/crypto.js

@@ -0,0 +1,124 @@
+/**
+ * crypto — Web Crypto's compute slice: getRandomValues + randomUUID.
+ *
+ * Entropy rides the host's CSPRNG through the same channel Math.random seeds
+ * from: WASI `random_get` under host:'wasi', an `env.random` byte-fill (wired
+ * by interop from globalThis.crypto.getRandomValues) under host:'js'. A
+ * numeric `randomSeed` option switches BOTH into a deterministic xorshift32
+ * stream — reproducible runs for sims/tests, explicitly NOT cryptographic
+ * (documented divergence; the default entropy mode IS the host CSPRNG).
+ *
+ * getRandomValues keeps the spec's guards (integer typed arrays only, ≤ 64 KiB
+ * per call) and returns its argument. randomUUID mints a lowercase v4 UUID.
+ * crypto.subtle stays out by doctrine — security crypto is out of scope.
+ *
+ * @module crypto
+ */
+
+import { typed, asI64 } from '../src/ir.js'
+import { emit, wat, hostImport, bind } from '../src/bridge.js'
+import { inc, declGlobal, PTR } from '../src/ctx.js'
+
+export default (ctx) => {
+  const seeded = typeof ctx.transform.randomSeed === 'number'
+  const seedConst = seeded ? ((ctx.transform.randomSeed >>> 0) || 1) : 0 // xorshift dies on 0
+  const wasi = ctx.transform.host === 'wasi'
+
+  const needEntropy = () => wasi
+    ? hostImport('wasi_snapshot_preview1', 'random_get',
+        ['func', '$__random_get', ['param', 'i32'], ['param', 'i32'], ['result', 'i32']])
+    : hostImport('env', 'random',
+        ['func', '$__env_random', ['param', 'i32'], ['param', 'i32']])
+
+  if (seeded) {
+    declGlobal('crypto.state', 'i32', seedConst)
+    wat('__crypto_fill', `(func $__crypto_fill (param $dst i32) (param $len i32)
+    (local $s i32) (local $i i32)
+    (local.set $s (global.get $crypto.state))
+    (block $d (loop $l
+      (br_if $d (i32.ge_s (local.get $i) (local.get $len)))
+      (local.set $s (i32.xor (local.get $s) (i32.shl (local.get $s) (i32.const 13))))
+      (local.set $s (i32.xor (local.get $s) (i32.shr_u (local.get $s) (i32.const 17))))
+      (local.set $s (i32.xor (local.get $s) (i32.shl (local.get $s) (i32.const 5))))
+      (i32.store8 (i32.add (local.get $dst) (local.get $i)) (local.get $s))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $l)))
+    (global.set $crypto.state (local.get $s)))`)
+  } else {
+    wat('__crypto_fill', wasi
+      ? `(func $__crypto_fill (param $dst i32) (param $len i32)
+    (drop (call $__random_get (local.get $dst) (local.get $len))))`
+      : `(func $__crypto_fill (param $dst i32) (param $len i32)
+    (call $__env_random (local.get $dst) (local.get $len)))`)
+  }
+
+  // Spec guards (WebCryptoAPI §10.1.1): receiver must be an integer typed
+  // array (floats → TypeMismatchError), byteLength ≤ 65536 (QuotaExceeded).
+  // Element codes 0–5 are the int family; code 7 + the bigint flag is
+  // BigInt64/BigUint64 (allowed). Returns the receiver, filled.
+  wat('__get_random_values', `(func $__get_random_values (param $p i64) (result f64)
+    (local $aux i32) (local $et i32) (local $bl i32)
+    (if (i32.ne (call $__ptr_type (local.get $p)) (i32.const ${PTR.TYPED}))
+      (then (throw $__jz_err (f64.const 0))))
+    (local.set $aux (call $__ptr_aux (local.get $p)))
+    (local.set $et (i32.and (local.get $aux) (i32.const 7)))
+    (if (i32.and
+          (i32.gt_u (local.get $et) (i32.const 5))
+          (i32.eqz (i32.and (local.get $aux) (i32.const 16))))
+      (then (throw $__jz_err (f64.const 0))))
+    (local.set $bl (i32.shl (call $__len (local.get $p)) (call $__typed_shift (local.get $et))))
+    (if (i32.gt_u (local.get $bl) (i32.const 65536))
+      (then (throw $__jz_err (f64.const 0))))
+    (call $__crypto_fill (call $__typed_data (local.get $p)) (local.get $bl))
+    (f64.reinterpret_i64 (local.get $p)))`,
+    ['__crypto_fill', '__ptr_type', '__ptr_aux', '__len', '__typed_shift', '__typed_data'])
+
+  // Lowercase v4 UUID: 16 entropy bytes, version/variant bits, hex + dashes.
+  wat('__random_uuid', `(func $__random_uuid (result f64)
+    (local $buf i32) (local $base i32) (local $out i32)
+    (local $i i32) (local $j i32) (local $b i32) (local $n i32)
+    (local.set $buf (call $__alloc (i32.const 16)))
+    (call $__crypto_fill (local.get $buf) (i32.const 16))
+    (i32.store8 (i32.add (local.get $buf) (i32.const 6))
+      (i32.or (i32.and (i32.load8_u (i32.add (local.get $buf) (i32.const 6))) (i32.const 15)) (i32.const 64)))
+    (i32.store8 (i32.add (local.get $buf) (i32.const 8))
+      (i32.or (i32.and (i32.load8_u (i32.add (local.get $buf) (i32.const 8))) (i32.const 63)) (i32.const 128)))
+    (local.set $base (call $__alloc (i32.const 40)))
+    (i32.store (local.get $base) (i32.const 36))
+    (local.set $out (i32.add (local.get $base) (i32.const 4)))
+    (block $d (loop $l
+      (br_if $d (i32.ge_u (local.get $i) (i32.const 16)))
+      (local.set $b (i32.load8_u (i32.add (local.get $buf) (local.get $i))))
+      (local.set $n (i32.shr_u (local.get $b) (i32.const 4)))
+      (i32.store8 (i32.add (local.get $out) (local.get $j))
+        (select (i32.add (local.get $n) (i32.const 87)) (i32.add (local.get $n) (i32.const 48)) (i32.gt_u (local.get $n) (i32.const 9))))
+      (local.set $n (i32.and (local.get $b) (i32.const 15)))
+      (i32.store8 (i32.add (i32.add (local.get $out) (local.get $j)) (i32.const 1))
+        (select (i32.add (local.get $n) (i32.const 87)) (i32.add (local.get $n) (i32.const 48)) (i32.gt_u (local.get $n) (i32.const 9))))
+      (local.set $j (i32.add (local.get $j) (i32.const 2)))
+      ;; dash after bytes 3, 5, 7, 9 → 8-4-4-4-12
+      (if (i32.or
+            (i32.or (i32.eq (local.get $i) (i32.const 3)) (i32.eq (local.get $i) (i32.const 5)))
+            (i32.or (i32.eq (local.get $i) (i32.const 7)) (i32.eq (local.get $i) (i32.const 9))))
+        (then
+          (i32.store8 (i32.add (local.get $out) (local.get $j)) (i32.const 45))
+          (local.set $j (i32.add (local.get $j) (i32.const 1)))))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (br $l)))
+    (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $out)))`,
+    ['__crypto_fill', '__alloc', '__mkptr'])
+
+  bind('crypto.getRandomValues', (arr) => {
+    if (!seeded) needEntropy()
+    ctx.runtime.throws = true
+    ctx.features.typedarray = true
+    inc('__get_random_values')
+    return typed(['call', '$__get_random_values', asI64(emit(arr))], 'f64')
+  })
+
+  bind('crypto.randomUUID', () => {
+    if (!seeded) needEntropy()
+    inc('__random_uuid')
+    return typed(['call', '$__random_uuid'], 'f64')
+  })
+}

package/module/index.js

@@ -17,4 +17,6 @@ import date from './date.js'
 import simd from './simd.js'
 import fs from './fs.js'
 import web from './web.js'
-export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer, date, simd , atomics, fs, web }
+import crypto from './crypto.js'
+import navigator from './navigator.js'
+export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer, date, simd , atomics, fs, web, crypto, navigator }

package/module/math.js

@@ -262,6 +262,11 @@ export default (ctx) => {
     ], 'f64')
   }
   ctx.core.emit['math.fround'] = a => typed(['f64.promote_f32', ['f32.demote_f64', toNumF64(a, emit(a))]], 'f64')
+  // ES2025 Math.f16round — round to binary16 and back (kernels in core.js)
+  ctx.core.emit['math.f16round'] = a => {
+    inc('__f64_to_f16', '__f16_to_f64')
+    return typed(['call', '$__f16_to_f64', ['call', '$__f64_to_f16', toNumF64(a, emit(a))]], 'f64')
+  }
   // ES2025 Math.f16round — no wasm f16 ops, so round in software (exactly).
   reg('math.f16round', ['math.f16round'], a => fn('math.f16round', a))
 

package/module/navigator.js

@@ -0,0 +1,26 @@
+/**
+ * navigator — the one member with compute meaning: hardwareConcurrency.
+ * Pairs with jz.pool/SPMD workers for in-module tile sizing.
+ *
+ * host:'js' — reads through an `env.hardwareConcurrency` service (wired by
+ * interop from globalThis.navigator, present in browsers and Node ≥ 21).
+ * host:'wasi' — no host to ask: warns and folds to 1 (a loud, documented
+ * degradation; WASI p1 has no concurrency introspection).
+ *
+ * @module navigator
+ */
+
+import { typed } from '../src/ir.js'
+import { hostImport } from '../src/bridge.js'
+import { warn } from '../src/ctx.js'
+
+export default (ctx) => {
+  ctx.core.emit['navigator.hardwareConcurrency'] = () => {
+    if (ctx.transform.host === 'wasi') {
+      warn('host-global', `\`navigator.hardwareConcurrency\` has no WASI source — folded to 1; size worker pools from the embedder instead`, {})
+      return typed(['f64.const', 1], 'f64')
+    }
+    hostImport('env', 'hardwareConcurrency', ['func', '$__hw_concurrency', ['result', 'f64']])
+    return typed(['call', '$__hw_concurrency'], 'f64')
+  }
+}

package/module/schema.js

@@ -97,12 +97,20 @@ export function initSchema(ctx) {
     if (ctx.schema.poisoned?.has(varName)) return -1
     const vt = lookupValType(varName)
     if (vt !== VAL.OBJECT) return -1
-    // Structural subtyping: walk only schemas that contain this prop.
-    // Consistent slot across all → return slot; any mismatch → -1 (dynamic lookup).
+    // Structural subtyping — sound only under the FULL closed-world condition:
+    // the prop lives at the SAME slot in EVERY registered schema, so whatever
+    // sid this OBJECT receiver carries, the slot is right. Checking only the
+    // schemas that CONTAIN the prop (the old form) bet that no other schema's
+    // instance could flow here — wrong the moment two shapes share a binding:
+    // `p.x` on a {z,w,q} receiver read z (slot 0 of a foreign schema), and the
+    // write sibling `p.x = v` CORRUPTED z. Receivers with a genuinely unique
+    // prop still devirtualize via guardedSlotOf's runtime-guarded path.
     const bucket = byProp.get(prop)
-    if (!bucket) return -1
+    if (!bucket || bucket.length !== ctx.schema.list.length) return -1
     const slot = bucket[0].slot
     for (let i = 1; i < bucket.length; i++) if (bucket[i].slot !== slot) return -1
+    if (typeof process !== 'undefined' && process.env?.JZ_DBG_SLOTOF)
+      console.error('[slotof-structural]', varName, '.', prop, 'slot', slot, 'bucket', bucket.length, 'of', ctx.schema.list.length, 'schemas')
     return slot
   }