jz 0.4.0 → 0.5.0

package/module/array.js

@@ -9,8 +9,9 @@
  */
 
 import { typed, asF64, asI64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, allocPtr, multiCount, arrayLoop, elemLoad, elemStore, truthyIR, extractF64Bits, appendStaticSlots, mkPtrIR, slotAddr, isLiteralStr, resolveValType, undefExpr } from '../src/ir.js'
-import { emit, materializeMulti } from '../src/emit.js'
-import { valTypeOf, lookupValType, VAL, extractParams, updateRep, staticPropertyKey } from '../src/analyze.js'
+import { emit, buildArrayWithSpreads } from '../src/emit.js'
+import { valTypeOf, lookupValType, lookupNotString, VAL, extractParams, updateRep, staticPropertyKey, staticObjectProps, inlineArraySid } from '../src/analyze.js'
+import { structInline } from '../src/abi/index.js'
 import { ctx, inc, err, PTR, LAYOUT } from '../src/ctx.js'
 import { strHashLiteral } from './collection.js'
 
@@ -44,6 +45,25 @@ function hoistArrayValue(arr) {
 
 const arrayLenFromPtr = ptr => ['i32.load', ['i32.sub', ['local.get', `$${ptr}`], ['i32.const', 8]]]
 
+/** K schema-ordered field-value AST nodes of an object literal `{S}` for a
+ *  structInline `.push({S})`, or null if `lit` is not a plain static-key `{}`
+ *  literal carrying exactly schema `sid`'s fields. Mapped by name into schema
+ *  order so push sites with differing key order flatten to the same cell run. */
+function structLiteralFields(lit, sid) {
+  if (!Array.isArray(lit) || lit[0] !== '{}') return null
+  const parsed = staticObjectProps(lit.slice(1))
+  const schema = ctx.schema.list[sid]
+  if (!parsed || parsed.names.length !== schema.length) return null
+  const byName = new Map()
+  for (let i = 0; i < parsed.names.length; i++) byName.set(parsed.names[i], parsed.values[i])
+  const out = []
+  for (const name of schema) {
+    if (!byName.has(name)) return null
+    out.push(byName.get(name))
+  }
+  return out
+}
+
 // Pure-expression check: no statements, binders, control flow, or assignments.
 // Inlining is only safe for these — anything else needs the full closure machinery.
 const NOT_PURE_OPS = new Set([
@@ -115,6 +135,8 @@ function makeCallback(fn, argReps) {
               : typed(['f64.reinterpret_i64', ['i64.const', UNDEF_NAN]], 'f64')
             stmts.push(['local.set', `$${fresh}`, ae])
           }
+          // Emit-time rep seeding for inliner-fresh param locals (lifecycle:
+          // analysis already finished; these `inl_i` names didn't exist then).
           // Apply argReps hints (caller knows recv elem val type) to inlined-param
           // reps so emit(subst) sees `inl_i.val=NUMBER` and elides __to_num/__is_str_key.
           if (argReps) {
@@ -156,7 +178,7 @@ function callbackArgReps(arr) {
     const vt = lookupValType(arr)
     if (vt === VAL.TYPED) itemRep = { val: VAL.NUMBER }
     else if (vt === VAL.ARRAY) {
-      const elemVt = ctx.func.repByLocal?.get(arr)?.arrayElemValType
+      const elemVt = ctx.func.localReps?.get(arr)?.arrayElemValType
       if (elemVt) itemRep = { val: elemVt }
     }
   } else {
@@ -227,6 +249,7 @@ export default (ctx) => {
     ],
     __arr_set_idx_ptr: ['__arr_grow', '__ptr_offset'],
     __arr_push1: ['__arr_grow_known', '__ptr_offset'],
+    __arr_unshift: ['__arr_grow', '__len', '__ptr_offset'],
     __typed_idx: () => ctx.features.typedarray || ctx.features.external
       ? ['__len']
       : ['__len', '__ptr_offset'],
@@ -399,7 +422,54 @@ export default (ctx) => {
     return null
   }
 
+  // Array.from(items, mapfn): spec step 2 — if mapfn is not undefined and
+  // IsCallable(mapfn) is false, throw a TypeError before iterating items.
+  // An explicit `undefined` arrives as the literal node [null, undefined];
+  // treat it as absent. Statically flag literal forms that can't be callable.
+  const isUndefinedNode = (n) => n === undefined
+    || (Array.isArray(n) && n[0] == null && n.length === 2 && n[1] === undefined)
+  const isNonCallableMapFn = (n) => {
+    if (!Array.isArray(n)) return false        // undefined / identifier — unknown
+    const op = n[0]
+    if (op == null) return true                // [null,x] literal — null/number/bigint
+    if (op === '=>') return false              // arrow function — callable
+    if (op === '{}' || op === 'str' || op === 'strcat' || op === '//') return true
+    if (op === '[]' && n.length < 3) return true            // array literal
+    if (op === '()' && n[1] === 'Symbol') return true       // Symbol(...) result
+    return false                               // calls / member access — unknown
+  }
+
   ctx.core.emit['Array.from'] = (src, mapFn) => {
+    if (isUndefinedNode(mapFn)) mapFn = undefined
+    else if (isNonCallableMapFn(mapFn)) {
+      ctx.runtime.throws = true
+      return typed(['block', ['result', 'f64'], ['throw', '$__jz_err', ['f64.const', 0]]], 'f64')
+    }
+    // Array.from(string) → array of single-char strings. The generic __arr_from
+    // path memory.copies len*8 bytes from the string's byte storage (1 byte/char),
+    // reading far past its end → OOB trap. Iterate __str_idx per char instead.
+    if (resolveValType(src, valTypeOf, lookupValType) === VAL.STRING) {
+      inc('__str_idx', '__str_len')
+      const len = tempI32('sfl'), i = tempI32('sfi'), s = temp('sfs')
+      const lenIR = ['local.get', `$${len}`]
+      const out = allocPtr({ type: PTR.ARRAY, len: lenIR, tag: 'sfr' })
+      const cb = mapFn && makeCallback(mapFn, [null, { val: VAL.NUMBER }])
+      const ch = typed(['call', '$__str_idx', ['i64.reinterpret_f64', ['local.get', `$${s}`]], ['local.get', `$${i}`]], 'f64')
+      const item = cb ? cb.call([ch, idxArg(cb, i)]) : ch
+      const id = ctx.func.uniq++
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${s}`, asF64(emit(src))],
+        ['local.set', `$${len}`, ['call', '$__str_len', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]],
+        out.init,
+        ...(cb ? [cb.setup] : []),
+        ['local.set', `$${i}`, ['i32.const', 0]],
+        ['block', `$brk${id}`, ['loop', `$loop${id}`,
+          ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], lenIR]],
+          elemStore(out.local, i, asF64(item)),
+          ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
+          ['br', `$loop${id}`]]],
+        out.ptr], 'f64')
+    }
     const lengthExpr = arrayLikeLength(src)
     if (lengthExpr) {
       const len = tempI32('fl'), i = tempI32('fi')
@@ -421,8 +491,26 @@ export default (ctx) => {
           ['br', `$loop${id}`]]],
         out.ptr], 'f64')
     }
-    inc('__arr_from')
-    return typed(['call', '$__arr_from', asI64(emit(src))], 'f64')
+    if (!mapFn) {
+      inc('__arr_from')
+      return typed(['call', '$__arr_from', asI64(emit(src))], 'f64')
+    }
+    // mapfn present: iterate the source array element by element, reading each
+    // slot fresh inside the loop so a callback that mutates a not-yet-visited
+    // source element sees its update (spec reads source[k] per step).
+    inc('__len')
+    const cb = makeCallback(mapFn, [null, { val: VAL.NUMBER }])
+    const s = temp('afs'), len = tempI32('afl')
+    const out = allocPtr({ type: PTR.ARRAY, len: ['local.get', `$${len}`], tag: 'aff' })
+    const loop = arrayLoop(typed(['local.get', `$${s}`], 'f64'),
+      (_p, _l, i, item) => [elemStore(out.local, i, asF64(cb.call([item, idxArg(cb, i)])))], len)
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${s}`, asF64(emit(src))],
+      ['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${s}`]]]],
+      out.init,
+      cb.setup,
+      ...loop,
+      out.ptr], 'f64')
   }
 
   // Grow array if capacity insufficient. Returns (possibly new) NaN-boxed pointer.
@@ -482,17 +570,24 @@ export default (ctx) => {
   // once and read len from the inline header (i32.load base-8) — avoids __len's separate
   // forwarding follow. On the rare grow path the base is recomputed after relocation.
   ctx.core.stdlib['__arr_set_idx_ptr'] = `(func $__arr_set_idx_ptr (param $ptr i64) (param $i i32) (param $val f64) (result f64)
-    (local $base i32) (local $p f64)
+    (local $base i32) (local $p f64) (local $oldLen i32) (local $k i32)
     (local.set $p (f64.reinterpret_i64 (local.get $ptr)))
     (if (i32.lt_s (local.get $i) (i32.const 0))
       (then (return (local.get $p))))
     (local.set $base (call $__ptr_offset (local.get $ptr)))
-    (if (i32.ge_u (local.get $i)
-                  (i32.load (i32.sub (local.get $base) (i32.const 8))))
+    (local.set $oldLen (i32.load (i32.sub (local.get $base) (i32.const 8))))
+    (if (i32.ge_u (local.get $i) (local.get $oldLen))
       (then
         (local.set $p (call $__arr_grow (local.get $ptr) (i32.add (local.get $i) (i32.const 1))))
         (local.set $base (call $__ptr_offset (i64.reinterpret_f64 (local.get $p))))
-        (i32.store (i32.sub (local.get $base) (i32.const 8)) (i32.add (local.get $i) (i32.const 1)))))
+        (i32.store (i32.sub (local.get $base) (i32.const 8)) (i32.add (local.get $i) (i32.const 1)))
+        ;; gap slots [oldLen, i) are holes — fill with undefined, not zero
+        (local.set $k (local.get $oldLen))
+        (block $fdone (loop $fill
+          (br_if $fdone (i32.ge_u (local.get $k) (local.get $i)))
+          (i64.store (i32.add (local.get $base) (i32.shl (local.get $k) (i32.const 3))) (i64.const ${UNDEF_NAN}))
+          (local.set $k (i32.add (local.get $k) (i32.const 1)))
+          (br $fill)))))
     (f64.store
       (i32.add (local.get $base) (i32.shl (local.get $i) (i32.const 3)))
       (local.get $val))
@@ -538,53 +633,11 @@ export default (ctx) => {
       return typed(['block', ['result', 'f64'], ...body], 'f64')
     }
 
-    const minCap = Math.max(ctx.transform.optimize?.arrayMinCap | 0, 4)
-    const a = allocArray(0, Math.max(elems.length, minCap))
-    const out = temp('sa'), pos = tempI32('sp')
-    inc('__arr_set_idx_ptr')
-
-    const body = [
-      ...a.setup,
-      ['local.set', `$${out}`, a.ptr],
-      ['local.set', `$${pos}`, ['i32.const', 0]],
-    ]
-
-    for (const e of elems) {
-      if (Array.isArray(e) && e[0] === '...') {
-        const src = temp('ss'), slen = tempI32('sl'), si = tempI32('si')
-        const id = ctx.func.uniq++
-        const spreadVal = multiCount(e[1]) ? materializeMulti(e[1]) : asF64(emit(e[1]))
-        const srcVT = valTypeOf(e[1])
-        const spreadItem = srcVT === VAL.ARRAY
-          ? (inc('__arr_idx_known'), ['call', '$__arr_idx_known', ['i64.reinterpret_f64', ['local.get', `$${src}`]], ['local.get', `$${si}`]])
-          : srcVT === VAL.STRING
-            ? (inc('__str_idx'), ['call', '$__str_idx', ['i64.reinterpret_f64', ['local.get', `$${src}`]], ['local.get', `$${si}`]])
-            : ctx.module.modules['string']
-              ? ['if', ['result', 'f64'],
-                ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${src}`]]], ['i32.const', PTR.STRING]],
-                ['then', (inc('__str_idx'), ['call', '$__str_idx', ['i64.reinterpret_f64', ['local.get', `$${src}`]], ['local.get', `$${si}`]])],
-                ['else', (['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${src}`]], ['local.get', `$${si}`]])]]
-              : (['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${src}`]], ['local.get', `$${si}`]])
-
-        body.push(
-          ['local.set', `$${src}`, spreadVal],
-          ['local.set', `$${slen}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${src}`]]]],
-          ['local.set', `$${si}`, ['i32.const', 0]],
-          ['block', `$brk${id}`, ['loop', `$loop${id}`,
-            ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${si}`], ['local.get', `$${slen}`]]],
-            ['local.set', `$${out}`, ['call', '$__arr_set_idx_ptr', ['i64.reinterpret_f64', ['local.get', `$${out}`]], ['local.get', `$${pos}`], spreadItem]],
-            ['local.set', `$${pos}`, ['i32.add', ['local.get', `$${pos}`], ['i32.const', 1]]],
-            ['local.set', `$${si}`, ['i32.add', ['local.get', `$${si}`], ['i32.const', 1]]],
-            ['br', `$loop${id}`]]])
-      } else {
-        body.push(
-          ['local.set', `$${out}`, ['call', '$__arr_set_idx_ptr', ['i64.reinterpret_f64', ['local.get', `$${out}`]], ['local.get', `$${pos}`], asF64(emit(e))]],
-          ['local.set', `$${pos}`, ['i32.add', ['local.get', `$${pos}`], ['i32.const', 1]]])
-      }
-    }
-
-    body.push(['local.get', `$${out}`])
-    return typed(['block', ['result', 'f64'], ...body], 'f64')
+    // Spread literal: buildArrayWithSpreads pre-sums the total length, allocates
+    // exact, and bulk-copies ARRAY sources with a single memory.copy — vs the
+    // per-element __arr_set_idx_ptr grow loop. Normalise the parser's `['...', x]`.
+    return buildArrayWithSpreads(elems.map(e =>
+      Array.isArray(e) && e[0] === '...' ? ['__spread', e[1]] : e))
   }
 
   // === Index read ===
@@ -596,6 +649,8 @@ export default (ctx) => {
     if (typeof arr !== 'string' && !(Array.isArray(arr) && arr[0] === 'local.get')) {
       const vtArr = valTypeOf(arr)
       const h = temp('ai')
+      // Emit-time rep seed on fresh hoist-temp `h` so the recursive emit
+      // below (`ctx.core.emit['[]'](h, idx)`) takes the typed-arr fast path.
       if (vtArr) updateRep(h, { val: vtArr })
       const setup = ['local.set', `$${h}`, asF64(emit(arr))]
       const result = ctx.core.emit['[]'](h, idx)
@@ -613,12 +668,17 @@ export default (ctx) => {
     const litKey = isLiteralStr(idx) ? idx[1]
       : typeof arr === 'string' && lookupValType(arr) === VAL.OBJECT ? staticPropertyKey(idx)
       : null
+    // SRoA flat object: `o['k']` → `local.get $o#i` (analyze.js scanFlatObjects).
+    if (litKey != null && typeof arr === 'string' && ctx.func.flatObjects?.has(arr)) {
+      const fo = ctx.func.flatObjects.get(arr)
+      const fi = fo.names.indexOf(litKey)
+      if (fi >= 0) return typed(['local.get', `$${arr}#${fi}`], 'f64')
+    }
     if (litKey != null && typeof arr === 'string' && ctx.schema.find) {
       const slot = ctx.schema.find(arr, litKey)
       if (slot >= 0) {
         inc('__ptr_offset')
-        return typed(['f64.load',
-          ['i32.add', ['call', '$__ptr_offset', ['i64.reinterpret_f64', asF64(emit(arr))]], ['i32.const', slot * 8]]], 'f64')
+        return typed(ctx.abi.object.ops.load(['call', '$__ptr_offset', ['i64.reinterpret_f64', asF64(emit(arr))]], slot), 'f64')
       }
     }
     if (litKey != null && typeof arr === 'string' && lookupValType(arr) === VAL.HASH) {
@@ -656,9 +716,9 @@ export default (ctx) => {
       if (keyType === VAL.STRING) return typed(dynLoad(asF64(emit(arr)), asF64(emit(idx))), 'f64')
       if (useRuntimeKeyDispatch)
         return emitDynamicKeyDispatch(asF64(emit(arr)), keyExpr =>
-          ['f64.load', ['i32.add', ['call', '$__ptr_offset', ['i64.reinterpret_f64', inner]], ['i32.shl', asI32(typed(keyExpr, 'f64')), ['i32.const', 3]]]])
+          ctx.abi.array.ops.load(['call', '$__ptr_offset', ['i64.reinterpret_f64', inner]], asI32(typed(keyExpr, 'f64'))))
       return typed(
-        ['f64.load', ['i32.add', ['call', '$__ptr_offset', ['i64.reinterpret_f64', inner]], ['i32.shl', vi, ['i32.const', 3]]]],
+        ctx.abi.array.ops.load(['call', '$__ptr_offset', ['i64.reinterpret_f64', inner]], vi),
         'f64')
     }
     // HASH receiver with runtime string key: probe the HASH directly via
@@ -685,6 +745,24 @@ export default (ctx) => {
     if (keyType === VAL.STRING)
       return typed(dynLoad(ptrExpr, asF64(emit(idx))), 'f64')
     if (vt === 'array') {
+      // structInline Array<S>: element i is K consecutive inline f64 schema
+      // cells — no per-row heap object, no stored element pointer. `arr[i]` is
+      // the byte address of the element's first cell, returned as a first-class
+      // unboxed OBJECT pointer (schema S); `arr[i].field` then composes a plain
+      // `+field*8` off it. The narrower proved every use of this binding is one
+      // structInline handles (src/analyze.js analyzeStructInline).
+      const inlSid = inlineArraySid(arr)
+      if (inlSid != null) {
+        inc('__ptr_offset')
+        const baseI32 = tempI32('ab')
+        const K = ctx.schema.list[inlSid].length
+        const cell = typed(structInline(K).ops.elemAddr(
+          ['local.tee', `$${baseI32}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ptrExpr]]],
+          vi), 'i32')
+        cell.ptrKind = VAL.OBJECT
+        cell.ptrAux = inlSid
+        return cell
+      }
       // Known-ARRAY → __arr_idx (single forwarding follow + inline bounds check),
       // not __typed_idx (which does __len + __ptr_offset = two forwarding follows
       // plus type-dispatch overhead irrelevant for plain arrays).
@@ -699,7 +777,7 @@ export default (ctx) => {
       // NaN-boxed pointer for OBJECT/STRING; downstream typed() handles both).
       // Fast path fires on schemaId (Array<{x,y,z}> shapes) OR plain elem-val
       // (Array<NUMBER> from `.map(x => x*k)` etc.).
-      const rep = typeof arr === 'string' ? ctx.func.repByLocal?.get(arr) : null
+      const rep = typeof arr === 'string' ? ctx.func.localReps?.get(arr) : null
       const hasElemFact = rep?.arrayElemSchema != null
       if (hasElemFact && keyIsNum) {
         inc('__ptr_offset')
@@ -708,11 +786,9 @@ export default (ctx) => {
         // `i32.wrap_i64 (i64.reinterpret_f64 (f64.load …))` → `i32.load …`
         // when this load feeds a ptrUnboxed OBJECT field.
         const baseI32 = tempI32('ab')
-        return typed(['f64.load',
-          ['i32.add',
-            ['local.tee', `$${baseI32}`,
-              ['call', '$__ptr_offset', ['i64.reinterpret_f64', ptrExpr]]],
-            ['i32.shl', vi, ['i32.const', 3]]]], 'f64')
+        return typed(ctx.abi.array.ops.load(
+          ['local.tee', `$${baseI32}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ptrExpr]]],
+          vi), 'f64')
       }
       const baseTmp = temp()
       // Numeric key (literal or known-NUMBER name) → skip __is_str_key dispatch;
@@ -748,10 +824,23 @@ export default (ctx) => {
         })
       return typed((['call', '$__typed_idx', ['i64.reinterpret_f64', ptrExpr], vi]), 'f64')
     }
-    if (useRuntimeKeyDispatch)
+    // Pure-write narrowing: an `xs[i] = v` / `xs.length = n` site in this
+    // body, with no offsetting string-shape evidence (typeof string check,
+    // STRING_ONLY method call, string-literal assignment), proves `arr` isn't
+    // a primitive string. Skip the runtime `__ptr_type==STRING` gate —
+    // `__typed_idx` already handles both ARRAY and TYPED tags internally.
+    // Discharge analysis lives in src/infer.js (notStringEvidence source); flow-sensitive
+    // notString refinements (from `if (typeof x === 'string') return ...`) overlay via lookup.
+    const notString = typeof arr === 'string' && lookupNotString(arr)
+    // A provably-NUMBER key can never be a string key, so the `__is_str_key`
+    // dispatch is statically dead — its numeric arm is what runs. Fall through
+    // to the direct ptr_type==STRING ? __str_idx : __typed_idx form below, which
+    // indexes with the i32 `vi` and skips the per-element f64 round-trip + call.
+    // Mirrors the `&& !keyIsNum` guard in the known-array/typed branches above.
+    if (useRuntimeKeyDispatch && keyType !== VAL.NUMBER)
       return emitDynamicKeyDispatch(ptrExpr, keyExpr => {
         const keyI32 = asI32(typed(keyExpr, 'f64'))
-        if (ctx.module.modules['string']) {
+        if (ctx.module.modules['string'] && !notString) {
           return ['if', ['result', 'f64'],
             ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ptrExpr]], ['i32.const', PTR.STRING]],
             ['then', (inc('__str_idx'), ['call', '$__str_idx', ['i64.reinterpret_f64', ptrExpr], keyI32])],
@@ -760,7 +849,7 @@ export default (ctx) => {
         return (['call', '$__typed_idx', ['i64.reinterpret_f64', ptrExpr], keyI32])
       })
     // Unknown → runtime dispatch (string module loaded → check ptr_type)
-    if (ctx.module.modules['string'])
+    if (ctx.module.modules['string'] && !notString)
       return typed(
         ['if', ['result', 'f64'],
           ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ptrExpr]], ['i32.const', PTR.STRING]],
@@ -774,6 +863,23 @@ export default (ctx) => {
 
   // .push(val) → append, increment len, return array (possibly reallocated pointer)
   ctx.core.emit['.push'] = (arr, ...vals) => {
+    // structInline Array<S>: `.push({S})` writes the K schema fields as K
+    // consecutive f64 cells. Flatten the struct literal into K schema-ordered
+    // field-value nodes and fall through to the general multi-value store path
+    // — `len`/`cap` count physical cells, so `__arr_grow_known` and the cell
+    // loop are reused untouched; `.push` then returns the logical element count
+    // (`len / K`). K=1 stays a single value → the `__arr_push1` fast path.
+    const inlSid = inlineArraySid(arr)
+    const inlK = inlSid != null ? ctx.schema.list[inlSid].length : 0
+    if (inlSid != null) {
+      const flat = []
+      for (const v of vals) {
+        const fields = structLiteralFields(v, inlSid)
+        if (!fields) err(`structInline Array.push expects { ${ctx.schema.list[inlSid].join(', ')} } literal arguments`)
+        flat.push(...fields)
+      }
+      vals = flat
+    }
     // Out-of-line fast path: single value, named known-ARRAY receiver. One call +
     // var update instead of ~30 inlined instructions — the dominant size cost of
     // push-heavy code (e.g. watr's WASM emitter).
@@ -857,7 +963,11 @@ export default (ctx) => {
       else
         body.push(['local.set', `$${arr}`, ['local.get', `$${t}`]])
     }
-    body.push(['f64.convert_i32_s', ['local.get', `$${len}`]])
+    // structInline: `len` counts physical cells — `.push` returns the JS array
+    // length, i.e. the logical element count `len / K`.
+    body.push(['f64.convert_i32_s', inlK > 1
+      ? ['i32.div_s', ['local.get', `$${len}`], ['i32.const', inlK]]
+      : ['local.get', `$${len}`]])
 
     return typed(['block', ['result', 'f64'], ...body], 'f64')
   }
@@ -1647,5 +1757,5 @@ export default (ctx) => {
 
   // .join(sep) → concatenate array elements with separator string
   ctx.core.emit['.join'] = (arr, sep) => (inc('__str_join'),
-    typed(['call', '$__str_join', asI64(emit(arr)), asI64(emit(sep))], 'f64'))
+    typed(['call', '$__str_join', asI64(emit(arr)), asI64(emit(sep == null ? ['str', ','] : sep))], 'f64'))
 }