jz 0.5.1 → 0.6.0

package/module/date.js

@@ -10,15 +10,15 @@
  */
 
 import { typed, asF64, toNumF64, allocPtr, temp } from '../src/ir.js'
-import { emit } from '../src/emit.js'
+import { emit, deps } from '../src/bridge.js'
 import { inc, PTR } from '../src/ctx.js'
-import { VAL } from '../src/analyze.js'
+import { VAL } from '../src/reps.js'
 
 const MS_PER_DAY = 86400000
 const MAX_TIME = 8640000000000000
 
 export default (ctx) => {
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __date_days_from_year: [],
     __date_make_day: ['__date_days_from_year'],
     __date_make_time: [],
@@ -686,6 +686,18 @@ export default (ctx) => {
   ctx.core.emit['.getDay'] = ctx.core.emit['.getUTCDay']
   ctx.core.emit[`.${VAL.DATE}:getDay`] = ctx.core.emit[`.${VAL.DATE}:getUTCDay`]
 
+  ctx.core.emit['.getHours'] = ctx.core.emit['.getUTCHours']
+  ctx.core.emit[`.${VAL.DATE}:getHours`] = ctx.core.emit[`.${VAL.DATE}:getUTCHours`]
+
+  ctx.core.emit['.getMinutes'] = ctx.core.emit['.getUTCMinutes']
+  ctx.core.emit[`.${VAL.DATE}:getMinutes`] = ctx.core.emit[`.${VAL.DATE}:getUTCMinutes`]
+
+  ctx.core.emit['.getSeconds'] = ctx.core.emit['.getUTCSeconds']
+  ctx.core.emit[`.${VAL.DATE}:getSeconds`] = ctx.core.emit[`.${VAL.DATE}:getUTCSeconds`]
+
+  ctx.core.emit['.getMilliseconds'] = ctx.core.emit['.getUTCMilliseconds']
+  ctx.core.emit[`.${VAL.DATE}:getMilliseconds`] = ctx.core.emit[`.${VAL.DATE}:getUTCMilliseconds`]
+
   // ── UTC setter emit handlers ──────────────────────────────────────────────
 
   const emitDatePtr = (dateExpr) =>

package/module/function.js

@@ -10,11 +10,41 @@
  * @module fn
  */
 
-import { typed, asF64, asI32, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN } from '../src/ir.js'
-import { emit } from '../src/emit.js'
-import { isReassigned } from '../src/analyze.js'
-import { T, lookupValType, repOf, findFreeVars } from '../src/analyze.js'
-import { PTR, LAYOUT, inc, err } from '../src/ctx.js'
+import { typed, asF64, asI32, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN, appendStaticSlots } from '../src/ir.js'
+import { emit } from '../src/bridge.js'
+import { isReassigned } from '../src/ast.js'
+import { findFreeVars } from '../src/compile/analyze.js'
+import { T } from '../src/ast.js'
+import { lookupValType, repOf, VAL } from '../src/reps.js'
+import { valTypeOf } from '../src/kind.js'
+import { PTR, LAYOUT, inc, err, declGlobal } from '../src/ctx.js'
+
+// A closure whose every return value is provably a plain number lets each caller
+// skip the `__to_num` result coercion — the dominant per-sample cost in closure-heavy
+// numeric kernels (floatbeats etc.). The check is structural at make time: arithmetic /
+// bitwise / `|0` / math.* returns resolve via `valTypeOf`, as do chained numeric-closure
+// calls (`g(x)=>…; f()=>g(…)` — `g`'s entry is already set when the outer `f` is made,
+// since decls emit in order). An unprovable shape (polymorphic `a[i]`, a value-returning
+// fall-through, a bare local that could collide with a parent binding) stays boxed.
+const closureReturnExprs = (body) => {
+  if (!Array.isArray(body) || body[0] !== '{}') return [body]   // expression-bodied arrow
+  const stmts = Array.isArray(body[1]) && body[1][0] === ';' ? body[1].slice(1) : [body[1]]
+  const last = stmts[stmts.length - 1]
+  if (!Array.isArray(last) || last[0] !== 'return') return null  // may fall off the end with undefined
+  const rets = []
+  let ok = true
+  const walk = n => {
+    if (!ok || !Array.isArray(n) || n[0] === '=>') return        // don't descend into nested closures
+    if (n[0] === 'return') { if (n.length < 2) ok = false; else rets.push(n[1]); return }
+    for (let i = 1; i < n.length; i++) walk(n[i])
+  }
+  for (const s of stmts) walk(s)
+  return ok ? rets : null
+}
+const returnsPlainNumber = (body) => {
+  const rets = closureReturnExprs(body)
+  return !!rets && rets.length > 0 && rets.every(e => valTypeOf(e) === VAL.NUMBER)
+}
 
 const intConstExpr = (node) => {
   if (typeof node === 'number' && Number.isInteger(node)) return node
@@ -107,6 +137,11 @@ export default (ctx) => {
     // call_indirect on the captured pointer). Gated on isReassigned over the inner body
     // so a local rewrite of the captured name disables propagation.
     const captureDirectClosures = new Map()
+    // Propagate the parent's `nullable` mark: a capture whose parent binding can
+    // hold null/undefined (e.g. `let x = null` later assigned a number) must keep
+    // that fact inside the body, or the body's own write facts (val = NUMBER)
+    // would let `x == null` fold to a constant false and skip the guard.
+    const captureNullables = new Set()
     for (const name of envCaptures) {
       const vt = lookupValType(name)
       if (vt != null) captureValTypes.set(name, vt)
@@ -117,6 +152,7 @@ export default (ctx) => {
       const bodyName = ctx.func.directClosures?.get(name)
       if (bodyName && !isReassigned(body, name)) captureDirectClosures.set(name, bodyName)
       if (repOf(name)?.intCertain === true) captureIntCertain.add(name)
+      if (repOf(name)?.nullable) captureNullables.add(name)
     }
 
     const schemaNames = ctx.schema.vars?.size ? new Set(ctx.schema.vars.keys()) : null
@@ -134,17 +170,23 @@ export default (ctx) => {
     // All closures use uniform convention: (env: f64, args_array: f64) → f64
     // The body unpacks individual params from the args array
     const boxedCaptures = envCaptures.filter(c => ctx.func.boxed?.has(c))
+    // i32-narrowed cells travel with the capture: the closure body must access
+    // the shared cell at the same width the owner does (see funcFacts.cellTypes).
+    const cellI32Captures = boxedCaptures.filter(c => ctx.func.cellTypes?.has(c))
     const bodyFn = { name: fnName, params, body, captures: envCaptures, arity: 1,
       ...(restParam && { rest: restParam }),
       ...(defaults && { defaults }),
       ...(boxedCaptures.length && { boxed: new Set(boxedCaptures) }),
+      ...(cellI32Captures.length && { cellI32: new Set(cellI32Captures) }),
       ...(captureIntConsts.size && { intConsts: captureIntConsts }),
       ...(captureIntCertain.size && { intCertain: captureIntCertain }),
+      ...(captureNullables.size && { nullables: captureNullables }),
       ...(captureValTypes.size && { valTypes: captureValTypes }),
       ...(captureSchemaVars.size && { schemaVars: captureSchemaVars }),
       ...(captureTypedElems.size && { typedElems: captureTypedElems }),
       ...(captureDirectClosures.size && { directClosures: captureDirectClosures }) }
     ctx.closure.bodies.push(bodyFn)
+    if (returnsPlainNumber(body)) (ctx.closure.numericReturn ||= new Set()).add(fnName)
 
     const tableIdx = addToTable(fnName)
 
@@ -160,6 +202,27 @@ export default (ctx) => {
       return ir
     }
 
+    if (body._nonEscaping && ctx.transform.optimize) {
+      // Allocate environmental slots in the static data segment
+      const staticOff = appendStaticSlots(new Array(envCaptures.length).fill('0x0000000000000000'))
+      const block = []
+      // Store captured values in env: boxed cells as raw i32 in low 4 bytes, others as f64.
+      // Avoids i32↔f64 roundtrip; body loads via i32.load/f64.load using the same branch.
+      for (let i = 0; i < envCaptures.length; i++) {
+        const addr = ['i32.const', staticOff + i * 8]
+        if (ctx.func.boxed?.has(envCaptures[i]))
+          block.push(['i32.store', addr, ['local.get', `$${ctx.func.boxed.get(envCaptures[i])}`]])
+        else
+          block.push(['f64.store', addr, asF64(emit(envCaptures[i]))])
+      }
+      block.push(mkPtrIR(PTR.CLOSURE, tableIdx, ['i32.const', staticOff]))
+
+      const ir = typed(['block', ['result', 'f64'], ...block], 'f64')
+      ir.closureBodyName = fnName
+      ir.closureFuncIdx = tableIdx
+      return ir
+    }
+
     const t = tempI32('env')
 
     const block = [
@@ -195,7 +258,10 @@ export default (ctx) => {
 
     if (prebuiltArray) {
       // Spread path: decode array into inline slots. Slots beyond array len padded with UNDEF.
-      // Rest-param closures receive up to (MAX - fixedParams) spread elements (overflow lost).
+      // The full args array offset is published in $__closure_spill so a rest-param
+      // callee can recover elements beyond width W (the W inline slots hold args[0..W-1];
+      // the rest reads args[W..argc-1] straight from the spill array). Unbounded arity.
+      declGlobal('__closure_spill', 'i32')
       const arrT = tempI32('sa')
       const lenL = tempI32('sl')
       const setup = [
@@ -220,6 +286,7 @@ export default (ctx) => {
       return typed(['block', ['result', 'f64'],
         ...setup,
         ['local.set', `$${t}`, asF64(closureExpr)],
+        ['global.set', '$__closure_spill', ['local.get', `$${arrT}`]],
         ['call_indirect', ['type', '$ftN'],
           ['local.get', `$${t}`],
           ['local.get', `$${lenL}`],

package/module/index.js

@@ -13,4 +13,5 @@ import json from './json.js'
 import regex from './regex.js'
 import timer from './timer.js'
 import date from './date.js'
-export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer, date }
+import simd from './simd.js'
+export { math, core, array, object, string, number, fn, typedarray, collection, symbol, console, json, regex, timer, date, simd }

package/module/json.js

@@ -8,10 +8,12 @@
  * @module json
  */
 
-import { typed, asF64, asI64, temp, tempI32, nullExpr, undefExpr, allocPtr, slotAddr, mkPtrIR, extractF64Bits, appendStaticSlots, NULL_WAT, UNDEF_NAN, UNDEF_WAT } from '../src/ir.js'
-import { emit, emitBoolStr } from '../src/emit.js'
-import { T, valTypeOf, VAL } from '../src/analyze.js'
-import { err, inc, PTR, LAYOUT } from '../src/ctx.js'
+import { typed, asF64, asI64, toStrI64, temp, tempI32, nullExpr, undefExpr, allocPtr, slotAddr, mkPtrIR, extractF64Bits, appendStaticSlots, NULL_WAT, UNDEF_NAN, UNDEF_WAT, FALSE_NAN, TRUE_NAN, FALSE_IR, TRUE_IR } from '../src/ir.js'
+import { emit, bool, deps } from '../src/bridge.js'
+import { valTypeOf } from '../src/kind.js'
+import { T } from '../src/ast.js'
+import { VAL } from '../src/reps.js'
+import { err, inc, PTR, LAYOUT, declGlobal } from '../src/ctx.js'
 import { strHashLiteral } from './collection.js'
 
 function jsonConstString(ctx, expr) {
@@ -58,6 +60,60 @@ function literalValue(node) {
   return NOT_LIT
 }
 
+// A BigInt has no JSON representation: `JSON.stringify` of a bigint — anywhere in
+// the value graph — is a TypeError (ES JSON.stringify → SerializeJSONProperty).
+// Detects it in a resolved literal value so the caller can emit the throw rather
+// than handing the bigint to the host `JSON.stringify` (which crashes the fold).
+const literalHasBigInt = (v) =>
+  typeof v === 'bigint' ||
+  (Array.isArray(v) ? v.some(literalHasBigInt)
+    : !!v && typeof v === 'object' && Object.values(v).some(literalHasBigInt))
+
+// Fold a literal AST node directly to its compact JSON string (no replacer /
+// no space). Unlike the value-level `literalValue` + `JSON.stringify` path, this
+// renders the self-host kernel boolean marker `['bool', 1|0]` as true/false:
+// the value path can't, because jz carries a boolean as a 0/1 *number*, so the
+// kernel's compile-time `JSON.stringify` of the folded value emits "1"/"0", not
+// "true"/"false" (native folds via real JS booleans and is unaffected). Scalars
+// delegate to the value path for exact number/string formatting; anything not
+// cleanly renderable (undefined, holes, function/symbol) returns NOT_LIT so the
+// caller falls back. Returns a JSON string or NOT_LIT.
+function foldJsonStr(node) {
+  if (!Array.isArray(node)) return NOT_LIT
+  const op = node[0]
+  // `['bool', carrier]` — prepare wraps the 0/1 carrier as a number-literal node
+  // `[, 0|1]` on the kernel leg (bare number in native), so unwrap before testing.
+  if (op === 'bool') {
+    const c = Array.isArray(node[1]) ? node[1][1] : node[1]
+    return c ? 'true' : 'false'
+  }
+  if (op === '[') {
+    const parts = []
+    for (let i = 1; i < node.length; i++) {
+      const s = foldJsonStr(node[i])
+      if (s === NOT_LIT) return NOT_LIT
+      parts.push(s)
+    }
+    return '[' + parts.join(',') + ']'
+  }
+  if (op === '{}') {
+    const parts = []
+    for (let i = 1; i < node.length; i++) {
+      const e = node[i]
+      if (!Array.isArray(e) || e[0] !== ':' || (typeof e[1] !== 'string' && typeof e[1] !== 'number')) return NOT_LIT
+      const s = foldJsonStr(e[2])
+      if (s === NOT_LIT) return NOT_LIT
+      parts.push(JSON.stringify(String(e[1])) + ':' + s)
+    }
+    return '{' + parts.join(',') + '}'
+  }
+  // Scalar (number / string / null / u-): exact formatting via the value path.
+  const v = literalValue(node)
+  if (v === NOT_LIT || typeof v === 'bigint') return NOT_LIT   // bigint ⇒ TypeError, not a literal string
+  const s = JSON.stringify(v)
+  return s === undefined ? NOT_LIT : s   // undefined/function/symbol — defer
+}
+
 function jsonShapeString(ctx, expr) {
   if (typeof expr === 'string') return ctx.scope.shapeStrs?.get(expr) ?? null
   return null
@@ -78,15 +134,15 @@ function hashCapFor(n) {
 }
 
 export default (ctx) => {
-  Object.assign(ctx.core.stdlibDeps, {
+  deps({
     __stringify: ['__json_val', '__json_setgap', '__json_omit', '__jput', '__jput_str', '__jput_num', '__mkstr'],
     __json_setgap: ['__alloc', '__ptr_type', '__str_byteLen', '__char_at'],
     __json_omit: ['__ptr_type'],
     __json_enter: ['__alloc'],
     __jindent: ['__jput'],
     __json_val: ['__ptr_type', '__len', '__ptr_offset', '__jput', '__jindent', '__jput_num', '__jput_str', '__json_enter', '__json_leave', '__json_hash', '__json_obj'],
-    __json_hash: ['__ptr_offset', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val'],
-    __json_obj: ['__ptr_offset', '__ptr_aux', '__len', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val'],
+    __json_hash: ['__ptr_offset', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val', '__coll_order'],
+    __json_obj: ['__ptr_offset', '__ptr_aux', '__len', '__jput', '__jindent', '__jput_str', '__json_omit', '__json_enter', '__json_leave', '__json_val', '__coll_order'],
     __jput_num: ['__ftoa'],
     __jput_str: ['__char_at', '__str_byteLen'],
     __jp: ['__jp_val', '__jp_str', '__jp_num', '__jp_arr', '__jp_obj', '__sso_char', '__ptr_aux', '__ptr_type', '__ptr_offset', '__str_byteLen'],
@@ -116,7 +172,7 @@ export default (ctx) => {
     if (v == null) return nullExpr()
     if (typeof v === 'number') return asF64(emit(v))
     if (typeof v === 'string') return asF64(emit(['str', v]))
-    if (typeof v === 'boolean') return asF64(emit(v ? 1 : 0))
+    if (typeof v === 'boolean') return typed((v ? TRUE_IR : FALSE_IR).slice(), 'f64')
     if (Array.isArray(v)) {
       const a = allocPtr({ type: PTR.ARRAY, len: v.length, cap: Math.max(v.length, 4), tag: 'jarr' })
       const body = [a.init]
@@ -150,23 +206,23 @@ export default (ctx) => {
   // Scratch buffer approach: __json_buf is a growable output buffer.
   // Functions append bytes to it, __json_pos tracks current write position.
 
-  ctx.scope.globals.set('__jbuf', '(global $__jbuf (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__jpos', '(global $__jpos (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__jcap', '(global $__jcap (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__schema_tbl', '(global $__schema_tbl (mut i32) (i32.const 0))')
+  declGlobal('__jbuf', 'i32')
+  declGlobal('__jpos', 'i32')
+  declGlobal('__jcap', 'i32')
+  declGlobal('__schema_tbl', 'i32')
   // Pretty-print state for the `space` argument. $__jgap points at the gap
   // string bytes ($__jgaplen of them); $__jdepth is the live nesting depth.
   // $__jgaplen == 0 ⇒ compact mode — every indent emission below is gated on
   // it, so the no-space path stays byte-identical to the unindented output.
-  ctx.scope.globals.set('__jgap', '(global $__jgap (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__jgaplen', '(global $__jgaplen (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__jdepth', '(global $__jdepth (mut i32) (i32.const 0))')
+  declGlobal('__jgap', 'i32')
+  declGlobal('__jgaplen', 'i32')
+  declGlobal('__jdepth', 'i32')
   // Cycle-detection stack: the i64 values of the containers currently open on
   // the recursion path. JSON.stringify of a structure that points back at an
   // ancestor must throw a TypeError. $__jstack is a lazily-allocated buffer of
   // up to 256 entries; $__jsp is the live depth.
-  ctx.scope.globals.set('__jstack', '(global $__jstack (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__jsp', '(global $__jsp (mut i32) (i32.const 0))')
+  declGlobal('__jstack', 'i32')
+  declGlobal('__jsp', 'i32')
 
   // __jput(byte: i32) — append one byte to output buffer
   ctx.core.stdlib['__jput'] = `(func $__jput (param $b i32)
@@ -322,6 +378,16 @@ export default (ctx) => {
         (call $__jput_num (local.get $f)) (return)))
     ;; NaN-boxed pointer
     (local.set $type (call $__ptr_type (local.get $val)))
+    ;; Boolean atoms: FALSE_NAN / TRUE_NAN → "false" / "true"
+    (if (i64.eq (local.get $val) (i64.const ${FALSE_NAN}))
+      (then
+        (call $__jput (i32.const 102)) (call $__jput (i32.const 97))
+        (call $__jput (i32.const 108)) (call $__jput (i32.const 115))
+        (call $__jput (i32.const 101)) (return)))
+    (if (i64.eq (local.get $val) (i64.const ${TRUE_NAN}))
+      (then
+        (call $__jput (i32.const 116)) (call $__jput (i32.const 114))
+        (call $__jput (i32.const 117)) (call $__jput (i32.const 101)) (return)))
     ;; Plain NaN (type=0) → null
     (if (i32.eqz (local.get $type))
       (then
@@ -369,34 +435,35 @@ export default (ctx) => {
     (call $__jput (i32.const 110)) (call $__jput (i32.const 117))
     (call $__jput (i32.const 108)) (call $__jput (i32.const 108)))`
 
-  // __json_hash(val: i64) — stringify HASH/MAP: iterate slots, emit {"key":val,...}
-  // Slot layout: 24 bytes each — [hash:f64][key:f64][val:f64]. Empty slots have hash==0.
+  // __json_hash(val: i64) — stringify HASH/MAP: emit {"key":val,...} in insertion
+  // order. Slot layout: 24 bytes each — [hash:f64][key:f64][val:f64]. __coll_order
+  // returns the n live slot offsets sorted by packed seq, matching the JS spec.
   ctx.core.stdlib['__json_hash'] = `(func $__json_hash (param $val i64)
-    (local $off i32) (local $cap i32) (local $i i32) (local $slot i32) (local $first i32) (local $pv i64)
+    (local $off i32) (local $cap i32) (local $n i32) (local $i i32) (local $slot i32) (local $ord i32) (local $first i32) (local $pv i64)
     (local.set $off (call $__ptr_offset (local.get $val)))
     (local.set $cap (i32.load (i32.sub (local.get $off) (i32.const 4))))
+    (local.set $n (i32.load (i32.sub (local.get $off) (i32.const 8))))
+    (local.set $ord (call $__coll_order (local.get $off) (local.get $cap) (i32.const 24)))
     (local.set $first (i32.const 1))
     (call $__json_enter (local.get $val))
     (call $__jput (i32.const 123))
     (global.set $__jdepth (i32.add (global.get $__jdepth) (i32.const 1)))
     (block $d (loop $l
-      (br_if $d (i32.ge_s (local.get $i) (local.get $cap)))
-      (local.set $slot (i32.add (local.get $off) (i32.mul (local.get $i) (i32.const 24))))
-      (if (f64.ne (f64.load (local.get $slot)) (f64.const 0))
+      (br_if $d (i32.ge_s (local.get $i) (local.get $n)))
+      (local.set $slot (i32.load (i32.add (local.get $ord) (i32.shl (local.get $i) (i32.const 2)))))
+      (local.set $pv (i64.load (i32.add (local.get $slot) (i32.const 16))))
+      (if (i32.eqz (call $__json_omit (local.get $pv)))
         (then
-          (local.set $pv (i64.load (i32.add (local.get $slot) (i32.const 16))))
-          (if (i32.eqz (call $__json_omit (local.get $pv)))
-            (then
-              (if (i32.eqz (local.get $first))
-                (then (call $__jput (i32.const 44))))
-              (local.set $first (i32.const 0))
-              (call $__jindent)
-              (call $__jput (i32.const 34))
-              (call $__jput_str (i64.load (i32.add (local.get $slot) (i32.const 8))))
-              (call $__jput (i32.const 34))
-              (call $__jput (i32.const 58))
-              (if (global.get $__jgaplen) (then (call $__jput (i32.const 32))))
-              (call $__json_val (local.get $pv))))))
+          (if (i32.eqz (local.get $first))
+            (then (call $__jput (i32.const 44))))
+          (local.set $first (i32.const 0))
+          (call $__jindent)
+          (call $__jput (i32.const 34))
+          (call $__jput_str (i64.load (i32.add (local.get $slot) (i32.const 8))))
+          (call $__jput (i32.const 34))
+          (call $__jput (i32.const 58))
+          (if (global.get $__jgaplen) (then (call $__jput (i32.const 32))))
+          (call $__json_val (local.get $pv))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $l)))
     (global.set $__jdepth (i32.sub (global.get $__jdepth) (i32.const 1)))
@@ -411,14 +478,21 @@ export default (ctx) => {
   ctx.core.stdlib['__json_obj'] = `(func $__json_obj (param $val i64)
     (local $off i32) (local $sid i32) (local $keys i32) (local $nkeys i32)
     (local $i i32) (local $koff i32) (local $first i32) (local $pv i64)
+    (local $props i64) (local $poff i32) (local $pcap i32) (local $dn i32) (local $slot i32) (local $ord i32)
+    (local $j i32) (local $skip i32)
     (local.set $off (call $__ptr_offset (local.get $val)))
     (local.set $sid (call $__ptr_aux (local.get $val)))
-    ;; Load keys array from schema table: schema_tbl + sid * 8
-    (local.set $keys (call $__ptr_offset
-      (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))
-    (local.set $nkeys (call $__len
-      (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))
-    (local.set $koff (local.get $keys))
+    ;; Schema keys: schema_tbl + sid*8. Dyn-only programs (empty {} + computed
+    ;; o[k]=v) never allocate __schema_tbl, leaving it 0 — guard the read so the
+    ;; dyn-prop walk below still runs.
+    (local.set $nkeys (i32.const 0))
+    (local.set $koff (i32.const 0))
+    (if (i32.ne (global.get $__schema_tbl) (i32.const 0))
+      (then
+        (local.set $koff (call $__ptr_offset
+          (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))
+        (local.set $nkeys (call $__len
+          (i64.load (i32.add (global.get $__schema_tbl) (i32.shl (local.get $sid) (i32.const 3))))))))
     (local.set $first (i32.const 1))
     (call $__json_enter (local.get $val))
     (call $__jput (i32.const 123))
@@ -439,6 +513,54 @@ export default (ctx) => {
           (call $__json_val (local.get $pv))))
       (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (br $l)))
+    ;; Dynamic (off-schema) properties: heap OBJECTs carry a HASH propsPtr at
+    ;; off-16 (set by __dyn_set). Walk it in insertion order via __coll_order —
+    ;; schema-only enumeration would drop computed props (e.g. {} then o.a=1).
+    ;; Skip propsPtr entries whose key already appears in the schema: object
+    ;; literals with needsDynShadow(target)=true shadow-write each schema key
+    ;; into propsPtr so dyn-key reads can resolve via hash lookup. That mirror
+    ;; is a runtime acceleration, not an enumeration entity — without dedup,
+    ;; JSON output emits each schema key twice. Schema-key interns equal the
+    ;; keys we shadow-write (same compile-time string literal), so i64.eq matches.
+    (if (i32.ge_u (local.get $off) (global.get $__heap_start))
+      (then
+        (local.set $props (i64.load (i32.sub (local.get $off) (i32.const 16))))
+        (if (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}))
+          (then
+            (local.set $poff (call $__ptr_offset (local.get $props)))
+            (local.set $pcap (i32.load (i32.sub (local.get $poff) (i32.const 4))))
+            (local.set $dn (i32.load (i32.sub (local.get $poff) (i32.const 8))))
+            (local.set $ord (call $__coll_order (local.get $poff) (local.get $pcap) (i32.const 24)))
+            (local.set $i (i32.const 0))
+            (block $dd (loop $dl
+              (br_if $dd (i32.ge_s (local.get $i) (local.get $dn)))
+              (local.set $slot (i32.load (i32.add (local.get $ord) (i32.shl (local.get $i) (i32.const 2)))))
+              (local.set $pv (i64.load (i32.add (local.get $slot) (i32.const 16))))
+              (local.set $skip (i32.const 0))
+              (local.set $j (i32.const 0))
+              (block $sd (loop $sl
+                (br_if $sd (i32.ge_s (local.get $j) (local.get $nkeys)))
+                (if (i64.eq
+                      (i64.load (i32.add (local.get $slot) (i32.const 8)))
+                      (i64.load (i32.add (local.get $koff) (i32.shl (local.get $j) (i32.const 3)))))
+                  (then (local.set $skip (i32.const 1)) (br $sd)))
+                (local.set $j (i32.add (local.get $j) (i32.const 1)))
+                (br $sl)))
+              (if (i32.and (i32.eqz (local.get $skip)) (i32.eqz (call $__json_omit (local.get $pv))))
+                (then
+                  (if (i32.eqz (local.get $first)) (then (call $__jput (i32.const 44))))
+                  (local.set $first (i32.const 0))
+                  (call $__jindent)
+                  (call $__jput (i32.const 34))
+                  (call $__jput_str (i64.load (i32.add (local.get $slot) (i32.const 8))))
+                  (call $__jput (i32.const 34))
+                  (call $__jput (i32.const 58))
+                  (if (global.get $__jgaplen) (then (call $__jput (i32.const 32))))
+                  (call $__json_val (local.get $pv))))
+              (local.set $i (i32.add (local.get $i) (i32.const 1)))
+              (br $dl)))))))
     (global.set $__jdepth (i32.sub (global.get $__jdepth) (i32.const 1)))
     (if (i32.eqz (local.get $first)) (then (call $__jindent)))
     (call $__jput (i32.const 125))
@@ -460,19 +582,19 @@ export default (ctx) => {
 
   // === JSON.parse ===
 
-  ctx.scope.globals.set('__jpstr', '(global $__jpstr (mut i32) (i32.const 0))')  // input string offset
-  ctx.scope.globals.set('__jplen', '(global $__jplen (mut i32) (i32.const 0))')  // input length
-  ctx.scope.globals.set('__jppos', '(global $__jppos (mut i32) (i32.const 0))')  // current parse position
+  declGlobal('__jpstr', 'i32')  // input string offset
+  declGlobal('__jplen', 'i32')  // input length
+  declGlobal('__jppos', 'i32')  // current parse position
   // Side-channel hash for the most-recently-parsed string. __jp_str folds an
   // FNV-1a pass into its scan loop; __jp_obj forwards it to __hash_set_local_h
   // and skips the redundant __str_hash call inside the generic insert. 0 is a
   // sentinel meaning "string had escapes — recompute via __str_hash".
-  ctx.scope.globals.set('__jp_keyh', '(global $__jp_keyh (mut i32) (i32.const 0))')
+  declGlobal('__jp_keyh', 'i32')
   // Sticky syntax-error flag. Set by any parser sub-routine on malformed input;
   // checked once by __jp after the top-level value, which throws if it is set.
   // Sticky (never cleared mid-parse) so recursive descent need not thread an
   // error result through every call — __jp resets it per invocation.
-  ctx.scope.globals.set('__jp_err', '(global $__jp_err (mut i32) (i32.const 0))')
+  declGlobal('__jp_err', 'i32')
   // Runtime schema infrastructure. __schema_next points at the first free slot
   // in $__schema_tbl reserved for runtime registration; compile.js initializes
   // it to ctx.schema.list.length when __jp_obj is included. The schema cache
@@ -482,8 +604,8 @@ export default (ctx) => {
   // every __hash_set_local). Cache slot layout: i32 hash, i32 sid (8 bytes).
   // Hash 0 = empty slot; we bump <=1 to 2 like __str_hash to avoid sentinel
   // collision with valid hashes.
-  ctx.scope.globals.set('__schema_next', '(global $__schema_next (mut i32) (i32.const 0))')
-  ctx.scope.globals.set('__schema_cache', '(global $__schema_cache (mut i32) (i32.const 0))')
+  declGlobal('__schema_next', 'i32')
+  declGlobal('__schema_cache', 'i32')
 
   // Sentinel-driven peek: __jp copies input to a scratch buffer with 0xFF bytes
   // appended past the end. i32.load8_s sign-extends, so the sentinel reads as -1
@@ -905,9 +1027,17 @@ export default (ctx) => {
   // word[0]; AND-check word[1..] against the bytes after the parse position.
   // Past-end reads land in the 0xFF sentinel pad, which matches nothing.
   const litMatch = (word) => {
-    const tests = [...word].slice(1).map((c, i) =>
-      `(i32.eq (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const ${i + 1})))) (i32.const ${c.charCodeAt(0)}))`)
-    return tests.reduce((a, b) => `(i32.and ${a} ${b})`)
+    // Index with charCodeAt rather than `[...word]` spread: jz (self-host) does not
+    // spread a string into a char array, so the spread form yields an empty test set
+    // and the literal match folds to a constant-false `(if 0 …)` — breaking
+    // JSON.parse of true/false/null once jz compiles its own parser. The first char
+    // is already matched by the caller's `ch` switch, so compare offsets 1..len-1.
+    let acc = ''
+    for (let i = 1; i < word.length; i++) {
+      const t = `(i32.eq (i32.load8_u (i32.add (global.get $__jpstr) (i32.add (global.get $__jppos) (i32.const ${i})))) (i32.const ${word.charCodeAt(i)}))`
+      acc = acc ? `(i32.and ${acc} ${t})` : t
+    }
+    return acc
   }
   const litCase = (ch, word, valIR, adv) => `(if (i32.eq (local.get $ch) (i32.const ${ch}))
       (then (if ${litMatch(word)}
@@ -928,8 +1058,8 @@ export default (ctx) => {
     (if (i32.or (i32.and (i32.ge_s (local.get $ch) (i32.const 48)) (i32.le_s (local.get $ch) (i32.const 57)))
                 (i32.eq (local.get $ch) (i32.const 45)))
       (then (return (call $__jp_num))))
-    ${litCase(116, 'true', '(f64.const 1)', 4)}
-    ${litCase(102, 'false', '(f64.const 0)', 5)}
+    ${litCase(116, 'true', `(f64.const nan:${TRUE_NAN})`, 4)}
+    ${litCase(102, 'false', `(f64.const nan:${FALSE_NAN})`, 5)}
     ${litCase(110, 'null', NULL_WAT, 4)}
     ;; No production matched — malformed JSON value.
     (global.set $__jp_err (i32.const 1))
@@ -971,18 +1101,24 @@ export default (ctx) => {
     const expect = (byte) => `(if (i32.ne ${PEEK} (i32.const ${byte})) (then ${fail}))
     ${ADV(1)}`
     const expectText = (text) => [...text].map(c => expect(c.charCodeAt(0))).join('\n    ')
+    // Forward-declared with `let` (assigned below) so `parse` captures a boxed
+    // cell, not a not-yet-initialized `const` binding — the self-host kernel
+    // miscompiles the latter capture in this deeply-nested mutually-recursive
+    // context (parse ends up calling a garbage `parseObject`, emitting a corrupt
+    // node into the shaped parser).
+    let parseObject, parseArray
     const parse = (v, out) => {
       if (v == null) return `${expectText('null')}
     (local.set $${out} ${NULL_WAT})`
       if (typeof v === 'boolean') return `${expectText(v ? 'true' : 'false')}
-    (local.set $${out} (f64.const ${v ? 1 : 0}))`
+    (local.set $${out} (f64.const nan:${v ? TRUE_NAN : FALSE_NAN}))`
       if (typeof v === 'number') return `(local.set $${out} (call $__jp_num))`
       if (typeof v === 'string') return `${expect(34)}
     (local.set $${out} (call $__jp_str))`
       if (Array.isArray(v)) return parseArray(v[0], out)
       return parseObject(v, out)
     }
-    const parseObject = (v, out) => {
+    parseObject = (v, out) => {
       const keys = Object.keys(v)
       const obj = local('obj', 'i32')
       const val = local('val', 'f64')
@@ -1010,7 +1146,7 @@ export default (ctx) => {
       return `${body}
     (local.set $${out} (call $__mkptr (i32.const ${PTR.OBJECT}) (i32.const ${sid}) (local.get $${obj})))`
     }
-    const parseArray = (elem, out) => {
+    parseArray = (elem, out) => {
       const ptr = local('arr', 'i32')
       const len = local('alen', 'i32')
       const cap = local('acap', 'i32')
@@ -1139,13 +1275,28 @@ ${localDecls}
   // the runtime call entirely. The runtime `__stringify` path (which ignores a
   // replacer) handles every non-constant case unchanged.
   ctx.core.emit['JSON.stringify'] = (x, replacer, space) => {
+    // An explicit `null`/`undefined` replacer is spec-equivalent to none; only a
+    // real array/function replacer changes the result. (foldStringify normalizes
+    // the same way via literalValue.) Used by both peepholes below.
+    const noReplacer = replacer == null || literalValue(replacer) == null
+    // BigInt has no JSON form — spec throws a TypeError. Emit the throw for the
+    // statically-known cases (a top-level bigint expr, or a literal tree holding
+    // one); the host fold can't render a bigint either. A function/array replacer
+    // may rewrite the value, so defer to the fold/runtime path when one is present.
+    if (noReplacer) {
+      const lv = literalValue(x)
+      if (valTypeOf(x) === VAL.BIGINT || (lv !== NOT_LIT && literalHasBigInt(lv))) {
+        ctx.runtime.throws = true
+        return typed(['block', ['result', 'f64'], ['throw', '$__jz_err', ['f64.const', 0]]], 'f64')
+      }
+    }
     const folded = foldStringify(x, replacer, space)
     if (folded !== undefined) return folded
     // Scalar boolean: the working-rep is the 0/1 number carrier, so the runtime
     // tag-walker would emit "0"/"1". A boolean's JSON is the bare word
-    // true/false — exactly emitBoolStr. Guard on `replacer == null`: a replacer
-    // function may rewrite the top-level value, in which case fall to runtime.
-    if (replacer == null && valTypeOf(x) === VAL.BOOL) return emitBoolStr(x)
+    // true/false — exactly bool. Guard on no replacer: a replacer function may
+    // rewrite the top-level value, in which case fall to runtime.
+    if (noReplacer && valTypeOf(x) === VAL.BOOL) return bool(x)
     inc('__stringify')
     const spaceIR = asI64(space == null ? undefExpr() : emit(space))
     return typed(['call', '$__stringify', asI64(emit(x)), spaceIR], 'f64')
@@ -1153,6 +1304,12 @@ ${localDecls}
 
   // Returns folded IR, or `undefined` when any argument is non-constant.
   function foldStringify(x, replacer, space) {
+    // No replacer / no space: try the bool-aware AST string fold first so a
+    // literal boolean renders as true/false on the self-host leg (see foldJsonStr).
+    if (replacer == null && space == null) {
+      const s = foldJsonStr(x)
+      if (s !== NOT_LIT) return asF64(emit(['str', s]))
+    }
     const val = literalValue(x)
     if (val === NOT_LIT) return undefined
 
@@ -1210,6 +1367,14 @@ ${localDecls}
       } catch { /* fall through to generic runtime parser */ }
     }
     inc('__jp')
-    return typed(['call', '$__jp', asI64(emit(x))], 'f64')
+    const value = temp('jp_arg')
+    const input = valTypeOf(x) === VAL.BOOL
+      ? asI64(bool(x))
+      : valTypeOf(x) === VAL.STRING
+        ? ['i64.reinterpret_f64', ['local.get', `$${value}`]]
+        : toStrI64(null, typed(['local.get', `$${value}`], 'f64'))
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${value}`, asF64(emit(x))],
+      ['call', '$__jp', input]], 'f64')
   }
 }