jz 0.5.1 → 0.6.0

package/module/symbol.js

@@ -19,7 +19,7 @@
  */
 
 import { typed, asF64, mkPtrIR } from '../src/ir.js'
-import { emit } from '../src/emit.js'
+import { emit } from '../src/bridge.js'
 import { err, inc, PTR } from '../src/ctx.js'
 
 const RESERVED = 16  // first user atom ID

package/module/timer.js

@@ -27,17 +27,12 @@
  */
 
 import { typed, asF64, asI64, UNDEF_NAN, MAX_CLOSURE_ARITY, temp, tempI64 } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { inc, PTR, LAYOUT } from '../src/ctx.js'
+import { emit, deps, hostImport } from '../src/bridge.js'
+import { inc, PTR, LAYOUT, declGlobal } from '../src/ctx.js'
 
 const MAX_TIMERS = 64
 const ENTRY_SIZE = 40
 
-const addImportOnce = (ctx, mod, name, fn) => {
-  if (ctx.module.imports.some(i => i[1] === `"${mod}"` && i[2] === `"${name}"`)) return
-  ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, fn])
-}
-
 // Shared "fire a NaN-boxed closure with 0 args" trampoline. Funcref index lives
 // in upper 16 bits of the pointer payload; remaining $ftN slots get UNDEF_NAN.
 // Closure is also passed as $__env so captures resolve via env-load.
@@ -55,7 +50,7 @@ const setupWasi = (ctx) => {
   // Always include init + tick + loop when timer module loads (structural, not per-emitter)
   inc('__timer_init', '__timer_tick', '__timer_loop')
 
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __timer_init: ['__alloc'],
     __timer_add: ['__time_ns'],
     __timer_cancel: [],
@@ -68,7 +63,7 @@ const setupWasi = (ctx) => {
   // call_indirect always matches the $ftN type (env, argc, a0..a7)
   ctx.closure.floor = MAX_CLOSURE_ARITY
 
-  addImportOnce(ctx, 'wasi_snapshot_preview1', 'clock_time_get',
+  hostImport('wasi_snapshot_preview1', 'clock_time_get',
     ['func', '$__clock_time_get', ['param', 'i32'], ['param', 'i64'], ['param', 'i32'], ['result', 'i32']])
 
   // __time_ns() → i64 — current monotonic nanoseconds
@@ -235,9 +230,9 @@ const setupWasi = (ctx) => {
   // $__timer_queue: i32 — base address of timer array
   // $__timer_next_id: i32 — next timer ID
   // $__timer_count: i32 — number of active timers
-  ctx.scope.globals.set('__timer_queue', '(global $__timer_queue (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__timer_next_id', '(global $__timer_next_id (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__timer_count', '(global $__timer_count (mut i32) (i32.const 0))')
+  declGlobal('__timer_queue', 'i32')
+  declGlobal('__timer_next_id', 'i32')
+  declGlobal('__timer_count', 'i32')
 
   // Emitter: setTimeout(closure, delay) → timer_id
   ctx.core.emit['setTimeout'] = (closureExpr, delayExpr) => {
@@ -279,9 +274,9 @@ const setupJsHost = (ctx) => {
   // canonicalization at the wasm→JS boundary (same reason as env.print —
   // see module/console.js header). delay is a real numeric f64 (no NaN-box
   // hazard), repeat is i32, return is the timer id (numeric int).
-  const needSetTimeout = () => addImportOnce(ctx, 'env', 'setTimeout',
+  const needSetTimeout = () => hostImport('env', 'setTimeout',
     ['func', '$__set_timeout', ['param', 'i64'], ['param', 'f64'], ['param', 'i32'], ['result', 'f64']])
-  const needClearTimeout = () => addImportOnce(ctx, 'env', 'clearTimeout',
+  const needClearTimeout = () => hostImport('env', 'clearTimeout',
     ['func', '$__clear_timeout', ['param', 'f64'], ['result', 'f64']])
 
   ctx.core.stdlib['__invoke_closure'] = invokeClosureFn(true)

package/module/typedarray.js

@@ -7,23 +7,17 @@
  * @module typed
  */
 
-import { typed, asF64, asI32, asI64, toNumF64, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, temp, tempI32, tempI64, undefExpr, truthyIR } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
-import { inc, PTR } from '../src/ctx.js'
-
-
-// Element types and their byte sizes
-const ELEM = {
-  Int8Array: 0, Uint8Array: 1,
-  Int16Array: 2, Uint16Array: 3,
-  Int32Array: 4, Uint32Array: 5,
-  Float32Array: 6, Float64Array: 7,
-  BigInt64Array: 7, BigUint64Array: 7,
-}
-const BIGINT_ELEM_FLAG = 16
-const typedAux = (name, isView = false) => ELEM[name] | (isView ? 8 : 0) |
-  (name === 'BigInt64Array' || name === 'BigUint64Array' ? BIGINT_ELEM_FLAG : 0)
+import { typed, asF64, asI32, asI64, toNumF64, UNDEF_NAN, allocPtr, mkPtrIR, ptrOffsetIR, ptrTypeEq, temp, tempI32, tempI64, undefExpr, truthyIR } from '../src/ir.js'
+import { emit, idx, deps, call } from '../src/bridge.js'
+import { valTypeOf } from '../src/kind.js'
+import { VAL, lookupValType } from '../src/reps.js'
+import { nanPrefixHex, TYPED_ELEM_NAMES, TYPED_ELEM_CODE, TYPED_ELEM_BIGINT_FLAG, encodeTypedElemAux } from '../layout.js'
+import { inc, PTR, getter } from '../src/ctx.js'
+
+const _NAN_BITS = nanPrefixHex()
+
+
+const typedAux = (name, isView = false) => encodeTypedElemAux(name, isView)
 const STRIDE = [1, 1, 2, 2, 4, 4, 4, 8]
 const SHIFT = [0, 0, 1, 1, 2, 2, 2, 3]
 const LOAD = [
@@ -202,11 +196,14 @@ function genSimdMap(name, elemType, pattern) {
 
 
 export default (ctx) => {
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __byte_length: ['__ptr_type', '__ptr_offset', '__ptr_aux'],
     __byte_offset: ['__ptr_type', '__ptr_offset', '__ptr_aux'],
     __to_buffer: ['__ptr_type', '__ptr_offset', '__ptr_aux', '__mkptr'],
     __typed_set_idx: ['__ptr_aux', '__ptr_offset'],
+    // __str_join uses __typed_idx when typedarray is loaded (plain arrays promoted to
+    // Int32Array by promoteIntArrayLiterals can produce PTR.TYPED results via .map()).
+    __str_join: [...(ctx.core.stdlibDeps.__str_join ?? []), '__typed_idx'],
   })
 
   // .map invokes with arity 1; .forEach/.find/.some/.every/.filter/.findIndex
@@ -217,6 +214,10 @@ export default (ctx) => {
 
   inc('__mkptr', '__alloc', '__len')
 
+  const buf = call('__to_buffer', 'I')
+  const blen = call('__byte_length', 'I', 'i32')
+  const boff = call('__byte_offset', 'I', 'i32')
+
   // === Runtime helpers: byte length, buffer coerce ===
   // __typed_shift lives in core (needed by __len/__cap).
 
@@ -261,7 +262,7 @@ export default (ctx) => {
           (else (call $__mkptr (i32.const ${PTR.BUFFER}) (i32.const 0) (local.get $off)))))))`
 
   // Constructor: new Float64Array(len) | new F64Array(arr) | new F64Array(buf) | new F64Array(buf, off, len)
-  for (const [name, elemType] of Object.entries(ELEM)) {
+  for (const [name, elemType] of Object.entries(TYPED_ELEM_CODE)) {
     const aux = typedAux(name)
     const stride = STRIDE[elemType]
     ctx.core.emit[`new.${name}`] = (lenExpr, offsetExpr, lenExpr2) => {
@@ -317,7 +318,7 @@ export default (ctx) => {
               numAlloc.ptr]],
             // Pointer: array → copy elements; buffer/typed → zero-copy view on same offset
             ['else', ['if', ['result', 'f64'],
-              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${src}`]]], ['i32.const', PTR.ARRAY]],
+              ptrTypeEq(['local.get', `$${src}`], PTR.ARRAY),
               ['then', ctx.core.emit[`${name}.from`](src)],
               ['else', mkPtrIR(PTR.TYPED, aux,
                 ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${src}`]]])]]]]], 'f64')
@@ -404,14 +405,14 @@ export default (ctx) => {
   // .buffer — always aliased (zero-copy). BUFFER: passthrough.
   // Owned TYPED: retag as BUFFER at same offset — the byteLen header is shared.
   // TYPED view (incl. DataView): BUFFER at descriptor[8] (root parent data offset).
-  ctx.core.emit['.buffer'] = (obj) => {
+  ctx.core.emit['.buffer'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor === 'new.ArrayBuffer') return asF64(emit(obj))
       if (ctor?.startsWith('new.')) {
         const isView = ctor.endsWith('.view')
         const name = isView ? ctor.slice(4, -5) : ctor.slice(4)
-        if (ELEM[name] != null) {
+        if (TYPED_ELEM_CODE[name] != null) {
           const parentOff = isView
             ? ['i32.load', ['i32.add', ptrOffsetIR(emit(obj), VAL.TYPED), ['i32.const', 8]]]
             : ptrOffsetIR(emit(obj), VAL.TYPED)
@@ -419,13 +420,12 @@ export default (ctx) => {
         }
       }
     }
-    inc('__to_buffer')
-    return typed(['call', '$__to_buffer', asI64(emit(obj))], 'f64')
-  }
+    return buf(obj)
+  })
 
   // .byteLength — BUFFER: raw __len. Owned TYPED: elemCount * stride.
   // View TYPED (incl. DataView): descriptor[0], via the __byte_length fallback.
-  ctx.core.emit['.byteLength'] = (obj) => {
+  ctx.core.emit['.byteLength'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor === 'new.ArrayBuffer') {
@@ -434,7 +434,7 @@ export default (ctx) => {
       if (ctor && ctor.startsWith('new.')) {
         const isView = ctor.endsWith('.view')
         const name = isView ? ctor.slice(4, -5) : ctor.slice(4)
-        const et = ELEM[name]
+        const et = TYPED_ELEM_CODE[name]
         if (et != null) {
           if (isView) {
             return typed(['f64.convert_i32_s',
@@ -445,12 +445,11 @@ export default (ctx) => {
         }
       }
     }
-    inc('__byte_length')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_length', asI64(emit(obj))]], 'f64')
-  }
+    return blen(obj)
+  })
 
   // .byteOffset — owned: 0. View: descriptor[4] - descriptor[8].
-  ctx.core.emit['.byteOffset'] = (obj) => {
+  ctx.core.emit['.byteOffset'] = getter((obj) => {
     if (typeof obj === 'string') {
       const ctor = ctx.types.typedElem?.get(obj)
       if (ctor?.endsWith('.view')) {
@@ -462,11 +461,10 @@ export default (ctx) => {
               ['i32.load', ['i32.add', ['local.get', `$${t}`], ['i32.const', 4]]],
               ['i32.load', ['i32.add', ['local.get', `$${t}`], ['i32.const', 8]]]]]], 'f64')
       }
-      if (ctor?.startsWith('new.') && ELEM[ctor.slice(4)] != null) return typed(['f64.const', 0], 'f64')
+      if (ctor?.startsWith('new.') && TYPED_ELEM_CODE[ctor.slice(4)] != null) return typed(['f64.const', 0], 'f64')
     }
-    inc('__byte_offset')
-    return typed(['f64.convert_i32_s', ['call', '$__byte_offset', asI64(emit(obj))]], 'f64')
-  }
+    return boff(obj)
+  })
 
   // Runtime fallback for .byteOffset when variable view-ness is unknown.
   ctx.core.stdlib['__byte_offset'] = `(func $__byte_offset (param $ptr i64) (result i32)
@@ -488,8 +486,7 @@ export default (ctx) => {
   ctx.core.emit['ArrayBuffer.isView'] = (v) => {
     if (v === undefined) return typed(['f64.const', 0], 'f64')
     const va = asF64(emit(v))
-    return typed(['f64.convert_i32_s',
-      ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', va]], ['i32.const', PTR.TYPED]]], 'f64')
+    return typed(['f64.convert_i32_s', ptrTypeEq(va, PTR.TYPED)], 'f64')
   }
 
   // x instanceof Float64Array | Int32Array | … — typed-pointer predicate emitted
@@ -502,7 +499,7 @@ export default (ctx) => {
     const t = temp('ityp')
     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.TYPED]]], 'i32')
+      ptrTypeEq(['local.get', `$${t}`], PTR.TYPED)], 'i32')
   }
 
   // buf.slice(begin?, end?) on a BUFFER → fresh BUFFER with the byte range copied.
@@ -598,7 +595,7 @@ export default (ctx) => {
   // (cheap: 4 wasm ops) so `getFloat32`/`getFloat64` return a real-spec NaN value.
   ctx.core.stdlib['__canon_nan'] = `(func $__canon_nan (param $v f64) (result f64)
     (select
-      (f64.reinterpret_i64 (i64.const 0x7FF8000000000000))
+      (f64.reinterpret_i64 (i64.const ${_NAN_BITS}))
       (local.get $v)
       (f64.ne (local.get $v) (local.get $v))))`
   const canonNaN = (vIR) => { inc('__canon_nan'); return typed(['call', '$__canon_nan', vIR], 'f64') }
@@ -799,7 +796,7 @@ export default (ctx) => {
   }
 
   // TypedArray.from(arr) — convert regular array to typed array
-  for (const [name, elemType] of Object.entries(ELEM)) {
+  for (const [name, elemType] of Object.entries(TYPED_ELEM_CODE)) {
     const aux = typedAux(name)
     const stride = STRIDE[elemType], store = STORE[elemType]
     ctx.core.emit[`${name}.from`] = (src) => {
@@ -858,7 +855,7 @@ export default (ctx) => {
     if (!ctor) return null
     const isView = !chainOutput && ctor.endsWith('.view')
     const name = ctor.endsWith('.view') ? ctor.slice(4, -5) : ctor.slice(4)
-    const et = ELEM[name]
+    const et = TYPED_ELEM_CODE[name]
     return et == null ? null : { et, isView, isBigInt: name === 'BigInt64Array' || name === 'BigUint64Array' }
   }
 
@@ -913,7 +910,7 @@ export default (ctx) => {
             (local.set $et (i32.and (local.get $aux) (i32.const 7)))
             (if (result f64) (i32.ge_u (local.get $et) (i32.const 6))
               (then (if (result f64) (i32.eq (local.get $et) (i32.const 7))
-                (then (if (result f64) (i32.and (local.get $aux) (i32.const ${BIGINT_ELEM_FLAG}))
+                (then (if (result f64) (i32.and (local.get $aux) (i32.const ${TYPED_ELEM_BIGINT_FLAG}))
                   (then (f64.reinterpret_i64 (i64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))))))
                   (else (f64.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3)))))))
                 (else (f64.promote_f32 (f32.load (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 2))))))))
@@ -938,7 +935,7 @@ export default (ctx) => {
     (if (i32.ne (i32.and (local.get $aux) (i32.const 8)) (i32.const 0))
       (then (local.set $off (i32.load (i32.add (local.get $off) (i32.const 4))))))
     (local.set $et (i32.and (local.get $aux) (i32.const 7)))
-    (if (i32.and (local.get $aux) (i32.const ${BIGINT_ELEM_FLAG}))
+    (if (i32.and (local.get $aux) (i32.const ${TYPED_ELEM_BIGINT_FLAG}))
       (then (i64.store (i32.add (local.get $off) (i32.shl (local.get $i) (i32.const 3))) (i64.reinterpret_f64 (local.get $v))))
       (else
         (if (i32.eq (local.get $et) (i32.const 7))
@@ -960,11 +957,11 @@ export default (ctx) => {
     (local.get $v))`
 
   // Type-aware TypedArray read: arr[i]
-  ctx.core.emit['.typed:[]'] = (arr, idx) => {
+  ctx.core.emit['.typed:[]'] = (arr, i) => {
     const r = resolveElem(arr)
     if (r == null) return null // unknown type, fallback to generic
     const { et, isView, isBigInt } = r
-    const objIR = emit(arr), vi = asI32(emit(idx))
+    const objIR = emit(arr), vi = idx(i)
     const off = ['i32.add', typedDataAddr(objIR, isView), ['i32.shl', vi, ['i32.const', SHIFT[et]]]]
     if (isBigInt) return typed(['f64.reinterpret_i64', ['i64.load', off]], 'f64')
     if (et === 7) return typed(['f64.load', off], 'f64') // Float64Array
@@ -974,11 +971,11 @@ export default (ctx) => {
   }
 
   // Type-aware TypedArray write: arr[i] = val
-  ctx.core.emit['.typed:[]='] = (arr, idx, val, void_ = false) => {
+  ctx.core.emit['.typed:[]='] = (arr, i, val, void_ = false) => {
     const r = resolveElem(arr)
     if (r == null) return null
     const { et, isView, isBigInt } = r
-    const objIR = emit(arr), vi = asI32(emit(idx)), valIR = emit(val)
+    const objIR = emit(arr), vi = idx(i), valIR = emit(val)
     const off = ['i32.add', typedDataAddr(objIR, isView), ['i32.shl', vi, ['i32.const', SHIFT[et]]]]
     if (isBigInt) {
       const vt = temp('tw')
@@ -1213,7 +1210,7 @@ export default (ctx) => {
   // ABI width at 2 to spare a slot across the whole program). Reduce passes
   // (acc, item). Closure invocation goes through `ctx.closure.call` directly.
   // The element-type-name list is needed by allocPtr for typedAux:
-  const ET_NAME = ['Int8Array','Uint8Array','Int16Array','Uint16Array','Int32Array','Uint32Array','Float32Array','Float64Array']
+  const ET_NAME = TYPED_ELEM_NAMES
 
   // .forEach: callback (item, idx). Result is 0 to match array.js's
   // convention (spec says undefined; both modules pick 0 since f() exposes the

package/package.json

@@ -1,37 +1,56 @@
 {
   "name": "jz",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Functional JS subset compiling to WASM",
   "main": "index.js",
   "type": "module",
   "exports": {
     ".": "./index.js",
     "./wasi": "./wasi.js",
-    "./interop": "./interop.js"
+    "./interop": "./interop.js",
+    "./transform": "./transform.js"
   },
   "files": [
     "index.js",
     "cli.js",
     "wasi.js",
     "interop.js",
+    "layout.js",
+    "transform.js",
+    "jzify",
     "src",
     "module",
-    "README.md"
+    "README.md",
+    "jz.svg",
+    "alternatives.svg",
+    "bench/bench.svg"
   ],
   "bin": {
     "jz": "cli.js"
   },
   "scripts": {
     "test": "node test/index.js",
-    "test262": "node test/test262.js",
-    "test262:builtins": "node test/test262-builtins.js",
+    "test:opt0": "JZ_TEST_OPTIMIZE=0 node test/index.js",
+    "test:opt1": "JZ_TEST_OPTIMIZE=1 node test/index.js",
+    "test:opt3": "JZ_TEST_OPTIMIZE=3 node test/index.js",
+    "test:wasi": "JZ_TEST_HOST=wasi node test/index.js",
+    "test:wasm": "JZ_TEST_TARGET=jz.wasm node test/index.js",
+    "test:matrix": "npm test && npm run test:opt0 && npm run test:opt3 && npm run test:wasi",
+    "test:bench": "node test/bench.js",
+    "test:fuzz": "node test/fuzz.js --count=5000",
+    "test:ratchet": "node test/perf-ratchet.js",
+    "test:self": "node test/selfhost.js",
+    "test:262": "node test/test262.js",
+    "test:262:builtins": "node test/test262-builtins.js",
+    "test:all": "npm run test:matrix && npm run test:262 && npm run test:262:builtins && npm run test:bench && npm run test:self",
     "bench": "node bench/bench.mjs",
+    "bench:fuzz": "node scripts/fuzz-bench.mjs",
     "bench:size": "node scripts/bench-size.mjs",
     "bench:compile": "node scripts/bench-compile.mjs",
-    "build:examples": "for dir in examples/*; do node \"$dir/build.mjs\"; done",
-    "test:bench": "node test/bench.js",
-    "test:all": "npm test && npm run test:bench",
-    "prepublishOnly": "npm run test:all"
+    "bench:startup": "node scripts/bench-startup.mjs",
+    "build": "node scripts/build-dist.mjs",
+    "build:examples": "for dir in examples/*/; do [ -f \"$dir/build.mjs\" ] && node \"$dir/build.mjs\"; done",
+    "prepublishOnly": "npm test && npm run test:self"
   },
   "repository": {
     "type": "git",
@@ -44,8 +63,8 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.4.15",
-    "watr": "^4.6.9"
+    "subscript": "^10.4.17",
+    "watr": "^4.6.10"
   },
   "keywords": [
     "javascript",
@@ -53,9 +72,19 @@
     "compiler",
     "functional",
     "minimal",
-    "wasm"
+    "wasm",
+    "aot",
+    "simd",
+    "wasi",
+    "wat",
+    "dsp",
+    "audio",
+    "creative-coding",
+    "assemblyscript",
+    "porffor"
   ],
   "devDependencies": {
+    "esbuild": "^0.28.0",
     "tst": "^9.4.0"
   }
 }

package/src/abi/index.js

@@ -1,21 +1,5 @@
 /**
- * src/abi — internal codegen carriers.
- *
- * The `abi/` directory hosts compiler-internal codegen modules — one file per
- * value type, each exporting every carrier (slot strategy) the compiler may
- * pick for that type. **No user surface.** `opts.host` is the only knob users
- * see; internal representation is analysis-driven and per-site.
- *
- * Today the narrower has not yet been wired to pick carriers per site, so
- * each type module's `default` export is used as the carrier for every site
- * of that type. `ctx.abi.<type>` resolves to that default; codegen reads
- * `ctx.abi.string.ops.byteLen(...)` etc. Per-site dispatch arrives by
- * exposing all carriers (`ctx.abi.string.sso`, `.jsstring`) and letting
- * `narrow.js` tag each binding with a carrier choice.
- *
- * No presets, no preset-name discriminant, no public ABI knob — carrier
- * choice is analysis-driven, not user-pickable. See `.work/todo.md`
- * "Boundary protocol and internal representation" for the policy.
+ * src/abi — internal codegen carriers + per-site dispatch.
  *
  * @module src/abi
  */
@@ -25,11 +9,43 @@ import sso, { jsstring } from './string.js'
 import tagged from './object.js'
 import taggedLinear, { structInline } from './array.js'
 
-/** The default carrier bundle — what `ctx.abi` resolves to. Identity-stable
- *  reference so codegen can compare without string keys. */
-export const DEFAULTS = Object.freeze({ number: nanboxF64, string: sso, object: tagged, array: taggedLinear })
+/** All carriers per value type — keyed by stable id for rep.carrier lookup. */
+export const CARRIERS = Object.freeze({
+  number: Object.freeze({ nanboxF64 }),
+  string: Object.freeze({ sso, jsstring }),
+  object: Object.freeze({ tagged }),
+  array: Object.freeze({ taggedLinear, structInline }),
+})
+
+const DEFAULT_ID = Object.freeze({
+  number: 'nanboxF64',
+  string: 'sso',
+  object: 'tagged',
+  array: 'taggedLinear',
+})
+
+/** Pick carrier bundle for `type` given optional binding rep hints. */
+export function resolveCarrier(type, rep) {
+  const table = CARRIERS[type]
+  if (!table) return null
+  const id = rep?.carrier ?? DEFAULT_ID[type]
+  return table[id] ?? table[DEFAULT_ID[type]]
+}
+
+/** Default carrier ops bundle — backward-compatible flat shape on ctx.abi. */
+export const DEFAULTS = Object.freeze({
+  number: nanboxF64,
+  string: sso,
+  object: tagged,
+  array: taggedLinear,
+})
+
+/** ctx.abi bundle: default carriers + resolve() + registry. All access is by
+ *  fixed key (`ctx.abi.object.ops`, `.string`, `.resolve`, …), so a plain
+ *  literal — the shape jz compiles directly — is equivalent to the former
+ *  null-proto `Object.assign` merge. */
+export function makeAbi() {
+  return { ...DEFAULTS, carriers: CARRIERS, resolve: resolveCarrier }
+}
 
-// Carrier re-exports — for tests and tools that want to reach a specific
-// carrier directly. Per-site narrowing will use these via `ctx.abi.<type>`
-// once the narrower exposes the full carrier dictionary.
 export { nanboxF64, sso, jsstring, tagged, taggedLinear, structInline }

package/src/abi/string.js

@@ -56,42 +56,12 @@
 // take. Kept as a one-liner so each op reads as a single `call`.
 const ssoI64 = (sF64) => ['i64.reinterpret_f64', sF64]
 
-// LAYOUT lives in `src/ctx.js`, which loads this module mid-bootstrap (line 10
-// of ctx.js, before LAYOUT itself is bound). ESM live bindings mean the import
-// resolves but the value is `undefined` until ctx.js finishes. All charCodeAt /
-// inline paths read these constants at *call* time (compile-time, after ctx is
-// fully initialized) — never at module top level — so this is safe.
-import { LAYOUT } from '../ctx.js'
+import { isReassigned } from '../ast.js'
+import { LAYOUT, oobNanIR, ssoBitI64Hex } from '../../layout.js'
 
-// Local copy of analyze.js#isReassigned — pulling the real one creates a load-
-// order cycle (abi/string ← ctx ← analyze ← ir ← ctx). Kept minimal: detects
-// any `=`/compound-assign/`++`/`--` of `name` anywhere in `body`. `let`/`const`
-// declarations are NOT reassignments (the param can't be redeclared anyway,
-// but a shadowing inner `let s = ...` shouldn't poison the outer param's
-// fast path). False positives are conservative — we just disable the fast
-// path and fall through to shape 2.
-const _CC_ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??='])
-const _paramReassigned = (body, name) => {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (_CC_ASSIGN_OPS.has(op) && body[1] === name) return true
-  if ((op === '++' || op === '--') && body[1] === name) return true
-  if (op === 'let' || op === 'const') {
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (Array.isArray(d) && d[0] === '=' && d[2] != null && _paramReassigned(d[2], name)) return true
-    }
-    return false
-  }
-  for (let i = 1; i < body.length; i++) if (_paramReassigned(body[i], name)) return true
-  return false
-}
-
-/** Pre-shifted SSO discriminator (bit 46 of the i64 ptr). Computed lazily on
- *  first read since LAYOUT is undefined when this module's top level runs.
- *  Memoized in the closure so all later call sites pay zero overhead. */
+/** Pre-shifted SSO discriminator — layout.js is cycle-free; memoized at first use. */
 let _ssoBitI64 = null
-const ssoBitI64 = () => _ssoBitI64 ??= '0x' + (BigInt(LAYOUT.SSO_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+const ssoBitI64 = () => _ssoBitI64 ??= ssoBitI64Hex()
 
 /** Allocate a fresh i64 local in the current function. Replicated here (not
  *  imported from `src/ir.js`) to keep this module loadable during ctx.js
@@ -134,7 +104,7 @@ function emitDecompCharRead(dec, iI32, ctx, oobNan) {
     ['else', heapByteExpr]]
   const use = ['if', ['result', rt],
     ['i32.ge_u', idx, ['local.get', `$${dec.len}`]],
-    ['then', oobNan ? ['f64.const', 'nan:0x7FF8000000000000'] : ['i32.const', 0]],
+    ['then', oobNan ? oobNanIR() : ['i32.const', 0]],
     ['else', oobNan ? ['f64.convert_i32_u', ccByte] : ccByte]]
   return spill
     ? ['block', ['result', rt], ['local.set', `$${spill}`, iI32], use]
@@ -252,7 +222,7 @@ export const sso = {
       //     being false to terminate; an i32 `0` would loop forever.
       // A fresh OOB node per use — IR nodes must not be structurally shared
       // (later passes mutate in place).
-      const mkOob = () => oobNan ? ['f64.const', 'nan:0x7FF8000000000000'] : ['i32.const', 0]
+      const mkOob = () => oobNan ? oobNanIR() : ['i32.const', 0]
       const rt = oobNan ? 'f64' : 'i32'
       const widen = b => oobNan ? ['f64.convert_i32_u', b] : b
       // Shape 1: receiver is a `local.get` of a non-boxed function parameter.
@@ -273,7 +243,7 @@ export const sso = {
         // to actually be `f64` (i64.reinterpret_f64 below would fail
         // validation otherwise — narrowed-to-int params have type 'i32').
         if (param && param.type === 'f64' && param.ptrKind == null
-            && !isBoxed && ctx.func.body && !_paramReassigned(ctx.func.body, name)) {
+            && !isBoxed && ctx.func.body && !isReassigned(ctx.func.body, name)) {
           if (!ctx.func.charDecomp) ctx.func.charDecomp = new Map()
           let dec = ctx.func.charDecomp.get(name)
           if (!dec) {
@@ -362,10 +332,31 @@ export const sso = {
       return preface
     },
 
-    /** Content equality. Both args: f64 slot carriers. Returns i32 boolean. */
+    /** Content equality. Both args: f64 slot carriers. Returns i32 boolean.
+     *  The bit-eq fast path is inlined at the site: static-literal dedup, SSO
+     *  packing and slice interning make identical bits the DOMINANT equal case
+     *  (a compiler comparing tree tags against literals hits it ~always), so
+     *  most comparisons skip the __str_eq call entirely. Content compare only
+     *  on bit-mismatch. */
     eq: (aF64, bF64, ctx) => {
       ctx.core.includes.add('__str_eq')
-      return ['call', '$__str_eq', ssoI64(aF64), ssoI64(bF64)]
+      // i64 temps allocated through the passed ctx — importing ir.js's tempI64
+      // here would close the abi→ir→ctx→abi module cycle the kernel bundler
+      // rejects (mirrors freshLocal's registration).
+      const fresh = () => {
+        let n
+        do { n = `seq${ctx.func.uniq++}` } while (ctx.func.locals.has(n))
+        ctx.func.locals.set(n, 'i64')
+        return n
+      }
+      const ta = fresh(), tb = fresh()
+      return ['block', ['result', 'i32'],
+        ['local.set', `$${ta}`, ssoI64(aF64)],
+        ['local.set', `$${tb}`, ssoI64(bF64)],
+        ['if', ['result', 'i32'],
+          ['i64.eq', ['local.get', `$${ta}`], ['local.get', `$${tb}`]],
+          ['then', ['i32.const', 1]],
+          ['else', ['call', '$__str_eq', ['local.get', `$${ta}`], ['local.get', `$${tb}`]]]]]
     },
 
     /** Three-way byte compare. Both args: f64 slot carriers. Returns i32 ∈ {-1, 0, 1}. */
@@ -375,8 +366,14 @@ export const sso = {
     },
 
     /** Concat with ToString coercion on both sides. Both args: f64 slot
-     *  carriers. Returns f64 (the new STRING ptr's slot carrier). */
-    concat: (aF64, bF64, ctx) => {
+     *  carriers. Returns f64 (the new STRING ptr's slot carrier).
+     *  Named `cat`, not `concat`: under self-host this op is invoked as a
+     *  method on the statically-untyped `ctx.abi.string.ops` receiver, and the
+     *  name `concat` collides with `Array.prototype.concat` — the method-call
+     *  dispatcher's string/array runtime guess (emit.js) would hijack it into a
+     *  bogus array concat. A non-builtin name routes through dynamic property
+     *  dispatch (load the closure slot, call it) correctly. */
+    cat: (aF64, bF64, ctx) => {
       ctx.core.includes.add('__str_concat')
       return ['call', '$__str_concat', ssoI64(aF64), ssoI64(bF64)]
     },