jz 0.1.1 → 0.2.1

package/src/emit.js

@@ -23,7 +23,7 @@
  */
 
 import { ctx, err, inc, PTR } from './ctx.js'
-import { T, VAL, valTypeOf, lookupValType, extractParams, classifyParam, findFreeVars, STMT_OPS, repOf, updateRep, repOfGlobal } from './analyze.js'
+import { T, VAL, valTypeOf, lookupValType, extractParams, classifyParam, findFreeVars, STMT_OPS, repOf, updateRep, repOfGlobal, staticPropertyKey } from './analyze.js'
 import {
   typed, asF64, asI32, asI64, asPtrOffset, asParamType, toI32, fromI64,
   NULL_IR, nullExpr, undefExpr, MAX_CLOSURE_ARITY,
@@ -34,6 +34,7 @@ import {
   isGlobal, isConst, keyValType, usesDynProps, needsDynShadow,
   temp, tempI32, tempI64, allocPtr,
   boxedAddr, readVar, writeVar, isNullish,
+  isLiteralStr, resolveValType, isFuncRef,
   multiCount, loopTop, flat,
   reconstructArgsWithSpreads,
 } from './ir.js'
@@ -42,6 +43,46 @@ import {
 // to decide whether to emit a value-returning or side-effect-only form.
 let _expect = null
 
+const FIRST_CLASS_UNARY_MATH = {
+  'math.abs': 'f64.abs',
+  'math.sqrt': 'f64.sqrt',
+  'math.ceil': 'f64.ceil',
+  'math.floor': 'f64.floor',
+  'math.trunc': 'f64.trunc',
+}
+
+function builtinFunctionValue(name) {
+  const op = FIRST_CLASS_UNARY_MATH[name]
+  if (!op) err(`Builtin function '${name}' cannot be used as a first-class value`)
+  if (!ctx.closure.table) err(`Builtin function '${name}' used as value requires closure support`)
+  const fn = `${T}builtin_${name.replace(/\W/g, '_')}`
+  if (!ctx.core.stdlib[fn]) {
+    const width = ctx.closure.width ?? MAX_CLOSURE_ARITY
+    const params = ['(param $__env f64)', '(param $__argc i32)']
+    for (let i = 0; i < width; i++) params.push(`(param $__a${i} f64)`)
+    ctx.core.stdlib[fn] = `(func $${fn} ${params.join(' ')} (result f64) (${op} (local.get $__a0)))`
+    inc(fn)
+  }
+  let idx = ctx.closure.table.indexOf(fn)
+  if (idx < 0) { idx = ctx.closure.table.length; ctx.closure.table.push(fn) }
+  const ir = mkPtrIR(PTR.CLOSURE, idx, 0)
+  ir.closureFuncIdx = idx
+  return ir
+}
+
+/** Emit unary negation: constant-fold, or i32 sub from 0 / f64.neg. */
+const emitNeg = (a) => {
+  if (valTypeOf(a) === VAL.BIGINT) return fromI64(['i64.sub', ['i64.const', 0], asI64(emit(a))])
+  const v = emit(a)
+  return isLit(v) ? emitNum(-litVal(v)) : v.type === 'i32'
+    ? typed(['i32.sub', typed(['i32.const', 0], 'i32'), v], 'i32')
+    : typed(['f64.neg', toNumF64(a, v)], 'f64')
+}
+
+/** Try constant-folding binary arith: returns emitNum(result) or null. */
+const foldConst = (va, vb, fn, guard) =>
+  isLit(va) && isLit(vb) && (!guard || guard(litVal(vb))) ? emitNum(fn(litVal(va), litVal(vb))) : null
+
 /** Emit typeof comparison: typeof x == typeCode → type-aware check. */
 export function emitTypeofCmp(a, b, cmpOp) {
   let typeofExpr, code
@@ -62,10 +103,7 @@ export function emitTypeofCmp(a, b, cmpOp) {
   if (code === -2) {
     inc('__ptr_type')
     const isPtr = ['f64.ne', ['local.tee', `$${t}`, va], ['local.get', `$${t}`]]
-    const tt = `${T}${ctx.func.uniq++}`; ctx.func.locals.set(tt, 'i32')
-    const isStr = ['i32.or',
-      ['i32.eq', ['local.tee', `$${tt}`, ['call', '$__ptr_type', ['local.get', `$${t}`]]], ['i32.const', PTR.STRING]],
-      ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.SSO]]]
+    const isStr = ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.STRING]]
     return typed(eq ? ['i32.and', isPtr, isStr]
       : ['i32.or', ['i32.eqz', isPtr], ['i32.eqz', isStr]], 'i32')
   }
@@ -81,9 +119,7 @@ export function emitTypeofCmp(a, b, cmpOp) {
     const isPtr = ['f64.ne', ['local.tee', `$${t}`, va], ['local.get', `$${t}`]]
     const tt = `${T}${ctx.func.uniq++}`; ctx.func.locals.set(tt, 'i32')
     const notStrFn = ['i32.and',
-      ['i32.and',
-        ['i32.ne', ['local.tee', `$${tt}`, ['call', '$__ptr_type', ['local.get', `$${t}`]]], ['i32.const', PTR.STRING]],
-        ['i32.ne', ['local.get', `$${tt}`], ['i32.const', PTR.SSO]]],
+      ['i32.ne', ['local.tee', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]], ['i32.const', PTR.STRING]],
       ['i32.ne', ['local.get', `$${tt}`], ['i32.const', PTR.CLOSURE]]]
     const notNullish = ['i32.eqz', isNullish(['local.get', `$${t}`])]
     const check = ['i32.and', ['i32.and', isPtr, notStrFn], notNullish]
@@ -92,13 +128,24 @@ export function emitTypeofCmp(a, b, cmpOp) {
   if (code === -6) {
     inc('__ptr_type')
     const isPtr = ['f64.ne', ['local.tee', `$${t}`, va], ['local.get', `$${t}`]]
-    const isFn = ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${t}`]], ['i32.const', PTR.CLOSURE]]
+    const isFn = ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', PTR.CLOSURE]]
     return typed(eq ? ['i32.and', isPtr, isFn] : ['i32.or', ['i32.eqz', isPtr], ['i32.eqz', isFn]], 'i32')
   }
+  if (code === -7) {
+    const vt = resolveValType(typeofExpr, valTypeOf, lookupValType)
+    if (vt) return typed(['i32.const', (vt === VAL.BIGINT) === eq ? 1 : 0], 'i32')
+    const n = ['local.tee', `$${t}`, va]
+    const isBigInt = ['i32.and',
+      ['f64.eq', n, ['local.get', `$${t}`]],
+      ['i32.and',
+        ['f64.ne', ['local.get', `$${t}`], ['f64.const', 0]],
+        ['f64.lt', ['f64.abs', ['local.get', `$${t}`]], ['f64.const', 2.2250738585072014e-308]]]]
+    return typed(eq ? isBigInt : ['i32.eqz', isBigInt], 'i32')
+  }
   if (code >= 0) {
     inc('__ptr_type')
     const isPtr = ['f64.ne', ['local.tee', `$${t}`, va], ['local.get', `$${t}`]]
-    const check = ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${t}`]], ['i32.const', code]]
+    const check = ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]], ['i32.const', code]]
     return typed(eq ? ['i32.and', isPtr, check] : ['i32.or', ['i32.eqz', isPtr], ['i32.eqz', check]], 'i32')
   }
   return null
@@ -112,9 +159,74 @@ const isCmp = n => Array.isArray(n) && CMP_SET.has(n[0])
 // heap strings) and BIGINT (content compare).
 const REF_EQ_KINDS = new Set([
   VAL.ARRAY, VAL.OBJECT, VAL.SET, VAL.MAP,
-  VAL.BUFFER, VAL.TYPED, VAL.CLOSURE, VAL.REGEX,
+  VAL.BUFFER, VAL.TYPED, VAL.CLOSURE, VAL.REGEX, VAL.DATE,
 ])
 
+function stringLiteral(node) {
+  if (Array.isArray(node) && node[0] === 'str' && typeof node[1] === 'string') return node[1]
+  if (Array.isArray(node) && node[0] == null && typeof node[1] === 'string') return node[1]
+  return null
+}
+
+function nonNegIntLiteral(node) {
+  const n = intLiteralValue(node)
+  return n != null && n >= 0 ? n : null
+}
+
+function emitSingleCharIndexCmp(a, b, negate = false) {
+  const leftLit = stringLiteral(a)
+  const rightLit = stringLiteral(b)
+  const aIdx = Array.isArray(a) && a[0] === '[]'
+  const bIdx = Array.isArray(b) && b[0] === '[]'
+  let indexed, lit
+  if (bIdx && leftLit != null) { indexed = b; lit = leftLit }
+  else if (aIdx && rightLit != null) { indexed = a; lit = rightLit }
+  else return null
+
+  if (lit.length === 0) return null
+  if ([...lit].some(c => c.charCodeAt(0) > 0x7F)) return null
+
+  const [, obj, key] = indexed
+  const idx = nonNegIntLiteral(key)
+  if (idx == null) return null
+
+  const vt = typeof obj === 'string' ? lookupValType(obj) : valTypeOf(obj)
+  if (vt && vt !== VAL.STRING) return null
+
+  const finish = expr => negate ? ['i32.eqz', expr] : expr
+
+  // Known STRING: s[i] always returns 1-char SSO. Multi-char literal → always false.
+  if (vt === VAL.STRING && lit.length > 1) return emitNum(negate ? 1 : 0)
+
+  // Single-char literal: compare byte directly, skipping __str_idx allocation.
+  if (lit.length !== 1 || !ctx.core.stdlib['__char_at'] || !ctx.core.stdlib['__str_byteLen']) return null
+
+  const ptr = temp('sc'), idxIR = ['i32.const', idx]
+  inc('__str_byteLen', '__char_at')
+  const charEq = ['if', ['result', 'i32'],
+    ['i32.gt_u', ['call', '$__str_byteLen', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]]], idxIR],
+    ['then', ['i32.eq', ['call', '$__char_at', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], idxIR], ['i32.const', lit.charCodeAt(0)]]],
+    ['else', ['i32.const', 0]]]
+
+  if (vt === VAL.STRING) {
+    return typed(['block', ['result', 'i32'],
+      ['local.set', `$${ptr}`, asF64(emit(obj))],
+      finish(charEq)], 'i32')
+  }
+
+  inc('__ptr_type', '__typed_idx', '__eq')
+  const genericEq = ['call', '$__eq',
+    ['i64.reinterpret_f64', ['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]], idxIR]],
+    asI64(emit(['str', lit]))]
+  const cmp = ['if', ['result', 'i32'],
+    ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${ptr}`]]], ['i32.const', PTR.STRING]],
+    ['then', charEq],
+    ['else', genericEq]]
+  return typed(['block', ['result', 'i32'],
+    ['local.set', `$${ptr}`, asF64(emit(obj))],
+    finish(cmp)], 'i32')
+}
+
 // === Flow-sensitive type refinement ===
 // Map typeof code (from resolveTypeof in prepare.js) → VAL kind. Undef/boolean/object have no
 // single VAL refinement, so they're excluded. String/number/function do.
@@ -219,6 +331,19 @@ function containsNestedLoop(body) {
   return false
 }
 
+function nestedSmallLoopBudget(body) {
+  if (!Array.isArray(body)) return 1
+  if (body[0] === '=>') return 1
+  if (body[0] === 'for') {
+    const [, init, cond, step, loopBody] = body
+    const n = smallConstForTripCount(init, cond, step)
+    return n == null ? MAX_NESTED_FOR_UNROLL + 1 : n * nestedSmallLoopBudget(loopBody)
+  }
+  let max = 1
+  for (let i = 1; i < body.length; i++) max = Math.max(max, nestedSmallLoopBudget(body[i]))
+  return max
+}
+
 function containsDeclOf(body, name) {
   if (!Array.isArray(body)) return false
   const op = body[0]
@@ -251,8 +376,17 @@ function cloneWithSubst(node, name, value) {
 }
 
 const MAX_SMALL_FOR_UNROLL = 8
+const MAX_NESTED_FOR_UNROLL = 64
 
-function unrollSmallConstFor(init, cond, step, body) {
+function containsKnownTypedArrayIndex(body) {
+  if (!Array.isArray(body)) return false
+  if (body[0] === '=>') return false
+  if (body[0] === '[]' && typeof body[1] === 'string' && ctx.types.typedElem?.has(body[1])) return true
+  for (let i = 1; i < body.length; i++) if (containsKnownTypedArrayIndex(body[i])) return true
+  return false
+}
+
+function smallConstForTripCount(init, cond, step) {
   if (!Array.isArray(init) || init[0] !== 'let' || init.length !== 2) return null
   const decl = init[1]
   if (!Array.isArray(decl) || decl[0] !== '=' || typeof decl[1] !== 'string') return null
@@ -268,8 +402,19 @@ function unrollSmallConstFor(init, cond, step, body) {
     (step[0] === '++' && step[1] === name) ||
     (step[0] === '-' && Array.isArray(step[1]) && step[1][0] === '++' && step[1][1] === name && intLiteralValue(step[2]) === 1)
   )
-  if (!stepOk) return null
-  if (hasOwnBreakOrContinue(body) || containsNestedClosure(body) || containsNestedLoop(body) || containsDeclOf(body, name)) return null
+  return stepOk ? end : null
+}
+
+function unrollSmallConstFor(init, cond, step, body) {
+  const end = smallConstForTripCount(init, cond, step)
+  if (end == null) return null
+  const name = init[1][1]
+  if (containsNestedLoop(body)) {
+    const nestedMode = ctx.transform.optimize?.nestedSmallConstForUnroll
+    if (nestedMode !== true && (nestedMode !== 'auto' || !containsKnownTypedArrayIndex(body))) return null
+    if (end * nestedSmallLoopBudget(body) > MAX_NESTED_FOR_UNROLL) return null
+  }
+  if (hasOwnBreakOrContinue(body) || containsNestedClosure(body) || containsDeclOf(body, name)) return null
   if (isReassigned(body, name)) return null
 
   const out = []
@@ -374,7 +519,7 @@ export function materializeMulti(callNode) {
     ? rawArgs[0].slice(1) : rawArgs
   const emittedArgs = argList.map((a, k) => emitArgForParam(emit(a), func.sig.params[k]))
   while (emittedArgs.length < func.sig.params.length)
-    emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : nullExpr())
+    emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : undefExpr())
   const temps = Array.from({ length: n }, () => temp())
   const out = allocPtr({ type: 1, len: n, tag: 'marr' })
   const ir = [out.init, ['call', `$${name}`, ...emittedArgs]]
@@ -391,13 +536,13 @@ export function emitDecl(...inits) {
   for (let ii = 0; ii < inits.length; ii++) {
     const i = inits[ii]
     if (typeof i === 'string') {
-      const undef = nullExpr()
+      const undef = undefExpr()
       if (ctx.func.boxed.has(i)) {
         const cell = ctx.func.boxed.get(i)
         ctx.func.locals.set(cell, 'i32')
-        result.push(
-          ['local.set', `$${cell}`, ['call', '$__alloc', ['i32.const', 8]]],
-          ['f64.store', ['local.get', `$${cell}`], undef])
+        if (!ctx.func.preboxed?.has(i))
+          result.push(['local.set', `$${cell}`, ['call', '$__alloc', ['i32.const', 8]]])
+        result.push(['f64.store', ['local.get', `$${cell}`], undef])
         continue
       }
       if (isGlobal(i)) {
@@ -436,7 +581,7 @@ export function emitDecl(...inits) {
             ? rawArgs[0].slice(1) : rawArgs
           const emittedArgs = argList.map((a, k) => emitArgForParam(emit(a), func.sig.params[k]))
           while (emittedArgs.length < func.sig.params.length)
-            emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : nullExpr())
+            emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : undefExpr())
           result.push(['call', `$${init[1]}`, ...emittedArgs])
           for (let k = n - 1; k >= 0; k--)
             result.push(['local.set', `$${targets[k]}`])
@@ -446,14 +591,14 @@ export function emitDecl(...inits) {
       }
     }
     const isObjLit = Array.isArray(init) && init[0] === '{}'
-    if (isObjLit) ctx.schema.targetStack.push(name)
+    if (isObjLit) ctx.schema.targetStack.push({ name, active: true })
     const val = emit(init)
     if (isObjLit) ctx.schema.targetStack.pop()
     // Direct-call dispatch for const-bound, non-escaping local closures: skip call_indirect.
     // Gate: not boxed (no mutable cross-fn capture), not global, not reassigned in this body.
     // isReassigned is conservative across nested arrow shadows — we miss the optimization
     // rather than emit a wrong direct call.
-    if (val?.closureBodyName && !ctx.func.boxed.has(name) && !isGlobal(name)
+    if (Array.isArray(init) && init[0] === '=>' && val?.closureBodyName && !ctx.func.boxed.has(name) && !isGlobal(name)
         && ctx.func.body && !isReassigned(ctx.func.body, name)) {
       if (!ctx.func.directClosures) ctx.func.directClosures = new Map()
       ctx.func.directClosures.set(name, val.closureBodyName)
@@ -461,9 +606,9 @@ export function emitDecl(...inits) {
     if (ctx.func.boxed.has(name)) {
       const cell = ctx.func.boxed.get(name)
       ctx.func.locals.set(cell, 'i32')
-      result.push(
-        ['local.set', `$${cell}`, ['call', '$__alloc', ['i32.const', 8]]],
-        ['f64.store', ['local.get', `$${cell}`], asF64(val)])
+      if (!ctx.func.preboxed?.has(name))
+        result.push(['local.set', `$${cell}`, ['call', '$__alloc', ['i32.const', 8]]])
+      result.push(['f64.store', ['local.get', `$${cell}`], asF64(val)])
       continue
     }
     if (isGlobal(name)) {
@@ -510,21 +655,21 @@ export function emitDecl(...inits) {
     } else {
       coerced = localType === 'f64' ? asF64(val) : asI32(val)
     }
-    if (!(isLit(coerced) && coerced[1] === 0 && !ctx.func.stack.length))
+    if (!(isLit(coerced) && coerced[1] === 0 && !Object.is(coerced[1], -0) && !ctx.func.stack.length))
       result.push(['local.set', `$${name}`, coerced])
 
     const schemaId = ctx.schema.idOf?.(name)
     if (ctx.func.localProps?.has(name) && schemaId != null) {
       const schema = ctx.schema.resolve(name)
       if (schema?.[0] === '__inner__') {
-        inc('__alloc', '__mkptr')
+        inc('__alloc_hdr', '__mkptr')
         const bt = `${T}bx${ctx.func.uniq++}`
         ctx.func.locals.set(bt, 'i32')
         const innerName = `${name}${T}inner`
         ctx.func.locals.set(innerName, 'f64')
         result.push(
           ['local.set', `$${innerName}`, ['local.get', `$${name}`]],
-          ['local.set', `$${bt}`, ['call', '$__alloc', ['i32.const', schema.length * 8]]],
+          ['local.set', `$${bt}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', Math.max(1, schema.length)], ['i32.const', 8]]],
           ['f64.store', ['local.get', `$${bt}`], ['local.get', `$${name}`]],
           ...schema.slice(1).map((_, j) =>
             ['f64.store', ['i32.add', ['local.get', `$${bt}`], ['i32.const', (j + 1) * 8]], ['f64.const', 0]]),
@@ -599,11 +744,11 @@ export function buildArrayWithSpreads(items) {
       const n = multiCount(sec.expr)
       ir.push(['local.set', `$${sec.local}`, n ? materializeMulti(sec.expr) : asF64(emit(sec.expr))])
       if (sec.baseLocal) {
-        ir.push(['local.set', `$${sec.baseLocal}`, ['call', '$__ptr_offset', ['local.get', `$${sec.local}`]]])
+        ir.push(['local.set', `$${sec.baseLocal}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]]]])
         ir.push(['local.set', `$${sec.lenLocal}`, ['i32.load', ['i32.sub', ['local.get', `$${sec.baseLocal}`], ['i32.const', 8]]]])
       } else {
         // Cache __len once per spread; reused below for total-len sum and inner copy bound.
-        ir.push(['local.set', `$${sec.lenLocal}`, ['call', '$__len', ['local.get', `$${sec.local}`]]])
+        ir.push(['local.set', `$${sec.lenLocal}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]]]])
       }
     }
   }
@@ -636,12 +781,10 @@ export function buildArrayWithSpreads(items) {
         ? ['f64.load', ['i32.add', ['local.get', `$${sec.baseLocal}`], ['i32.shl', ['local.get', `$${sidx}`], ['i32.const', 3]]]]
         : ctx.module.modules['string']
           ? ['if', ['result', 'f64'],
-            ['i32.or',
-              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${sec.local}`]], ['i32.const', PTR.STRING]],
-              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${sec.local}`]], ['i32.const', PTR.SSO]]],
-            ['then', (inc('__str_idx'), ['call', '$__str_idx', ['local.get', `$${sec.local}`], ['local.get', `$${sidx}`]])],
-            ['else', (inc('__typed_idx'), ['call', '$__typed_idx', ['local.get', `$${sec.local}`], ['local.get', `$${sidx}`]])]]
-          : (inc('__typed_idx'), ['call', '$__typed_idx', ['local.get', `$${sec.local}`], ['local.get', `$${sidx}`]])
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]]], ['i32.const', PTR.STRING]],
+            ['then', (inc('__str_idx'), ['call', '$__str_idx', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]], ['local.get', `$${sidx}`]])],
+            ['else', (inc('__typed_idx'), ['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]], ['local.get', `$${sidx}`]])]]
+          : (inc('__typed_idx'), ['call', '$__typed_idx', ['i64.reinterpret_f64', ['local.get', `$${sec.local}`]], ['local.get', `$${sidx}`]])
       ir.push(
         ['local.set', `$${sidx}`, ['i32.const', 0]],
         ['block', `$break${loopId}`, ['loop', `$loop${loopId}`,
@@ -710,6 +853,34 @@ export function emitBody(node) {
 const cmpOp = (i32op, f64op, fn) => (a, b) => {
   const va = emit(a), vb = emit(b)
   if (isLit(va) && isLit(vb)) return emitNum(fn(litVal(va), litVal(vb)) ? 1 : 0)
+  // String compare: NaN-boxed string pointers compare as NaN under f64.lt/gt
+  // (always false), so without this the spec-correct `"a" < "b"` returns 0.
+  // Route both-STRING operands through __str_cmp's three-way result, then apply
+  // the same i32 sign op as numeric (lt_s/gt_s/le_s/ge_s vs 0).
+  const vta = resolveValType(a, valTypeOf, lookupValType)
+  const vtb = resolveValType(b, valTypeOf, lookupValType)
+  if (vta === VAL.BIGINT || vtb === VAL.BIGINT) {
+    const op = bigintUnsignedBound(a) || bigintUnsignedBound(b) ? i32op.replace('_s', '_u') : i32op
+    return typed([`i64.${op}`, asI64(va), asI64(vb)], 'i32')
+  }
+  if (vta === VAL.STRING && vtb === VAL.STRING) {
+    inc('__str_cmp')
+    return typed([`i32.${i32op}`, ['call', '$__str_cmp', asI64(va), asI64(vb)], ['i32.const', 0]], 'i32')
+  }
+  if (vta === VAL.DATE || vtb === VAL.DATE) {
+    const dateNum = (node, v, vt) => {
+      if (vt !== VAL.DATE) return toNumF64(node, v)
+      const ptr = v.ptrKind === VAL.DATE
+        ? v
+        : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+      return typed(['f64.load', ptr], 'f64')
+    }
+    return typed([`f64.${f64op}`, dateNum(a, va, vta), dateNum(b, vb, vtb)], 'i32')
+  }
+  if (vtb === VAL.NUMBER && needsRelationalToNumber(a, vta))
+    return typed([`f64.${f64op}`, toNumF64(a, va), asF64(vb)], 'i32')
+  if (vta === VAL.NUMBER && needsRelationalToNumber(b, vtb))
+    return typed([`f64.${f64op}`, asF64(va), toNumF64(b, vb)], 'i32')
   const ai = intConstValue(a), bi = intConstValue(b)
   if (va.type === 'i32' && bi != null) return typed([`i32.${i32op}`, va, ['i32.const', bi]], 'i32')
   if (vb.type === 'i32' && ai != null) return typed([`i32.${i32op}`, ['i32.const', ai], vb], 'i32')
@@ -717,6 +888,16 @@ const cmpOp = (i32op, f64op, fn) => (a, b) => {
     ? typed([`i32.${i32op}`, va, vb], 'i32') : typed([`f64.${f64op}`, asF64(va), asF64(vb)], 'i32')
 }
 
+function needsRelationalToNumber(expr, vt) {
+  if (vt === VAL.STRING) return true
+  if (vt != null) return false
+  return mayReadBoxedValue(expr)
+}
+
+function mayReadBoxedValue(expr) {
+  return Array.isArray(expr) && (expr[0] === '.' || expr[0] === '[]' || expr[0] === '?.' || expr[0] === '?.[]')
+}
+
 function intConstValue(expr) {
   if (typeof expr === 'number' && Number.isInteger(expr)) return expr
   if (Array.isArray(expr) && expr[0] == null && typeof expr[1] === 'number' && Number.isInteger(expr[1])) return expr[1]
@@ -727,13 +908,45 @@ function intConstValue(expr) {
   return null
 }
 
+function bigintUnsignedBound(expr) {
+  const n = bigintConstValue(expr)
+  return n != null && n > 0x7fffffffffffffffn && n <= 0xffffffffffffffffn
+}
+
+function bigintConstValue(expr) {
+  if (typeof expr === 'bigint') return expr
+  if (!Array.isArray(expr)) return null
+  if (expr[0] == null && typeof expr[1] === 'bigint') return expr[1]
+  if (expr[0] === 'u-') {
+    const n = bigintConstValue(expr[1])
+    return n == null ? null : -n
+  }
+  return null
+}
+
+function arrayIndexKey(key) {
+  const n = Number(key)
+  const u = n >>> 0
+  return String(u) === key && u !== 0xffffffff ? u : null
+}
+
 /** Compound assignment: read → op → write back (via readVar/writeVar). */
 function compoundAssign(name, val, f64op, i32op) {
   if (typeof name === 'string' && isConst(name)) err(`Assignment to const '${name}'`)
   const void_ = _expect === 'void'
   const va = readVar(name), vb = emit(val)
-  if (i32op && va.type === 'i32' && vb.type === 'i32')
-    return writeVar(name, i32op(va, vb), void_)
+  // Peel f64.convert_i32_s/u when va is i32 — typed-array integer reads wrap their
+  // i32.load in convert_i32_* by default, but the i32 arithmetic path can use the
+  // raw i32 directly (eliminates per-iter widen + saturating-trunc roundtrip on
+  // hot accumulator loops like `let s = 0; for (...) s += i32arr[i]`).
+  let vbi = vb
+  if (i32op && va.type === 'i32' && vb.type !== 'i32' &&
+      Array.isArray(vb) && (vb[0] === 'f64.convert_i32_s' || vb[0] === 'f64.convert_i32_u')) {
+    const inner = vb[1]
+    vbi = Array.isArray(inner) ? typed(inner, 'i32') : inner
+  }
+  if (i32op && va.type === 'i32' && vbi.type === 'i32')
+    return writeVar(name, i32op(va, vbi), void_)
   return writeVar(name, f64op(asF64(va), asF64(vb)), void_)
 }
 
@@ -880,6 +1093,7 @@ export const emitter = {
 
   '=': (name, val) => {
     if (typeof name === 'string' && isConst(name)) err(`Assignment to const '${name}'`)
+    const void_ = _expect === 'void'
     // Array index assignment: arr[i] = x
     if (Array.isArray(name) && name[0] === '[]') {
       const [, arr, idx] = name
@@ -899,28 +1113,34 @@ export const emitter = {
           ['local.set', `$${arrTmp}`, arrExpr],
           ['local.set', `$${idxTmp}`, asI32(typed(idxNode, 'f64'))],
           ['local.set', `$${valTmp}`, valueExpr],
-          ['local.set', `$${arrTmp}`, ['call', '$__arr_set_idx_ptr', ['local.get', `$${arrTmp}`], ['local.get', `$${idxTmp}`], ['local.get', `$${valTmp}`]]],
+          ['local.set', `$${arrTmp}`, ['call', '$__arr_set_idx_ptr', ['i64.reinterpret_f64', ['local.get', `$${arrTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${valTmp}`]]],
         ]
         if (persist) body.push(persist(['local.get', `$${arrTmp}`]))
         body.push(['local.get', `$${valTmp}`])
         return typed(['block', ['result', 'f64'], ...body], 'f64')
       }
       const setDyn = () => {
+        if (ctx.transform.strict)
+          err(`strict mode: dynamic property assignment \`${typeof arr === 'string' ? arr : '<expr>'}[<expr>] = ...\` falls back to __dyn_set. Use a literal key or known array/typed-array numeric index, or pass { strict: false }.`)
         inc('__dyn_set')
-        return typed(['call', '$__dyn_set', asF64(emit(arr)), keyExpr, valueExpr], 'f64')
+        return typed(['f64.reinterpret_i64', ['call', '$__dyn_set', asI64(emit(arr)), asI64(keyExpr), asI64(valueExpr)]], 'f64')
       }
       const dispatchKey = (numericIR) => {
+        if (ctx.transform.strict)
+          err(`strict mode: dynamic property assignment \`${typeof arr === 'string' ? arr : '<expr>'}[<expr>] = ...\` falls back to __dyn_set. Use a literal key or known array/typed-array numeric index, or pass { strict: false }.`)
         const keyTmp = temp()
         return typed(['block', ['result', 'f64'],
           ['local.set', `$${keyTmp}`, keyExpr],
-          ['if', ['result', 'f64'], ['call', '$__is_str_key', ['local.get', `$${keyTmp}`]],
-            ['then', ['call', '$__dyn_set', asF64(emit(arr)), ['local.get', `$${keyTmp}`], valueExpr]],
+          ['if', ['result', 'f64'], ['call', '$__is_str_key', ['i64.reinterpret_f64', ['local.get', `$${keyTmp}`]]],
+            ['then', ['f64.reinterpret_i64', ['call', '$__dyn_set', asI64(emit(arr)), ['i64.reinterpret_f64', ['local.get', `$${keyTmp}`]], asI64(valueExpr)]]],
             ['else', numericIR(['local.get', `$${keyTmp}`])]]], 'f64')
       }
       // Literal string key on schema-known object → direct payload slot write (skip __dyn_set)
-      const litKey = Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string' ? idx[1] : null
+      const litKey = isLiteralStr(idx) ? idx[1]
+        : typeof arr === 'string' && lookupValType(arr) === VAL.OBJECT ? staticPropertyKey(idx)
+        : null
       if (litKey != null && typeof arr === 'string' && ctx.schema.find) {
-        const slot = ctx.schema.find(arr, litKey, true)
+        const slot = ctx.schema.find(arr, litKey)
         if (slot >= 0) {
           const t = temp()
           return typed(['block', ['result', 'f64'],
@@ -931,11 +1151,25 @@ export const emitter = {
             ['local.get', `$${t}`]], 'f64')
         }
       }
+      const arrIndex = litKey != null ? arrayIndexKey(litKey) : null
+      if (arrIndex != null && typeof arr === 'string' && keyValType(arr) === VAL.ARRAY) {
+        const persist = ptr => {
+          if (ctx.func.boxed?.has(arr)) return ['f64.store', boxedAddr(arr), ptr]
+          if (isGlobal(arr)) return ['global.set', `$${arr}`, ptr]
+          return ['local.set', `$${arr}`, ptr]
+        }
+        return storeArrayValue(asF64(emit(arr)), typed(['f64.const', arrIndex], 'f64'), persist)
+      }
       if (keyType === VAL.STRING) return setDyn()
       if (typeof arr === 'string' && ctx.core.emit['.typed:[]='] &&
           lookupValType(arr) === 'typed') {
-        const r = ctx.core.emit['.typed:[]=']?.(arr, idx, val)
+        const r = ctx.core.emit['.typed:[]=']?.(arr, idx, val, void_)
         if (r) return r
+        // Element ctor unknown — runtime aux-byte dispatch. __typed_set_idx
+        // returns the stored value as f64, used directly as the expr result.
+        inc('__typed_set_idx')
+        return typed(['call', '$__typed_set_idx',
+          asI64(emit(arr)), asI32(emit(idx)), valueExpr], 'f64')
       }
       if (typeof arr === 'string' && ctx.schema.isBoxed?.(arr)) {
         const inner = ctx.schema.emitInner(arr)
@@ -962,9 +1196,34 @@ export const emitter = {
         return storeArrayValue(asF64(va), keyExpr, persist)
       }
       // arr is non-ARRAY here (VAL.ARRAY branch was taken above); safe to skip forwarding.
-      const arrVT = (typeof arr === 'string' ? lookupValType(arr) : null) || VAL.OBJECT
+      const knownArrVT = typeof arr === 'string' ? lookupValType(arr) : null
+      const arrVT = knownArrVT || VAL.OBJECT
       if (useRuntimeKeyDispatch) {
         inc('__dyn_set', '__is_str_key')
+        // When arr type is unknown (could be TypedArray) and __typed_set_idx is
+        // available, dispatch the numeric branch through __ptr_type so TypedArray
+        // writes go by element type. Without this, ternary-typed arrays (e.g.
+        // `num === 4 ? new Uint32Array(4) : new Uint8Array(16)`) would silently
+        // f64.store boxed bytes regardless of element width.
+        const hasTypedSet = !!ctx.core.stdlib['__typed_set_idx']
+        if (knownArrVT == null && hasTypedSet) {
+          const objTmp = temp('asu')
+          const idxTmp = tempI32('asi')
+          inc('__ptr_type', '__typed_set_idx')
+          return dispatchKey(keyNode => {
+            const keyI32 = asI32(typed(keyNode, 'f64'))
+            return ['block', ['result', 'f64'],
+              ['local.set', `$${objTmp}`, asF64(va)],
+              ['local.set', `$${idxTmp}`, keyI32],
+              ['local.set', `$${t}`, vv],
+              ['if', ['result', 'f64'],
+                ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.TYPED]],
+                ['then', ['call', '$__typed_set_idx', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${t}`]]],
+                ['else', ['block', ['result', 'f64'],
+                  ['f64.store', ['i32.add', ptrOffsetIR(['local.get', `$${objTmp}`], arrVT), ['i32.shl', ['local.get', `$${idxTmp}`], ['i32.const', 3]]], ['local.get', `$${t}`]],
+                  ['local.get', `$${t}`]]]]]
+          })
+        }
         return dispatchKey(keyNode => {
           const keyI32 = asI32(typed(keyNode, 'f64'))
           return ['block', ['result', 'f64'],
@@ -973,6 +1232,62 @@ export const emitter = {
             ['local.get', `$${t}`]]
         })
       }
+      if (typeof arr !== 'string') {
+        const objTmp = temp('asu')
+        const idxTmp = tempI32('asi')
+        const ptrTmp = temp('asp')
+        const hasTypedSet = !!ctx.core.stdlib['__typed_set_idx']
+        inc('__ptr_type', '__arr_set_idx_ptr')
+        if (hasTypedSet) inc('__typed_set_idx')
+        return typed(['block', ['result', 'f64'],
+          ['local.set', `$${objTmp}`, asF64(va)],
+          ['local.set', `$${idxTmp}`, vi],
+          ['local.set', `$${t}`, vv],
+          ['if', ['result', 'f64'],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.ARRAY]],
+            ['then', ['block', ['result', 'f64'],
+              ['local.set', `$${ptrTmp}`, ['call', '$__arr_set_idx_ptr', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${t}`]]],
+              ['local.get', `$${t}`]]],
+            ['else', hasTypedSet ? ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.TYPED]],
+              ['then', ['call', '$__typed_set_idx', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${t}`]]],
+              ['else', ['block', ['result', 'f64'],
+                ['f64.store', ['i32.add', ptrOffsetIR(['local.get', `$${objTmp}`], arrVT), ['i32.shl', ['local.get', `$${idxTmp}`], ['i32.const', 3]]], ['local.get', `$${t}`]],
+                ['local.get', `$${t}`]]]] : ['block', ['result', 'f64'],
+              ['f64.store', ['i32.add', ptrOffsetIR(['local.get', `$${objTmp}`], arrVT), ['i32.shl', ['local.get', `$${idxTmp}`], ['i32.const', 3]]], ['local.get', `$${t}`]],
+              ['local.get', `$${t}`]]]]], 'f64')
+      }
+      if (typeof arr === 'string' && knownArrVT == null) {
+        const objTmp = temp('asu')
+        const idxTmp = tempI32('asi')
+        const ptrTmp = temp('asp')
+        const hasTypedSet = !!ctx.core.stdlib['__typed_set_idx']
+        inc('__ptr_type', '__arr_set_idx_ptr')
+        if (hasTypedSet) inc('__typed_set_idx')
+        const persist = ptr => {
+          if (ctx.func.boxed?.has(arr)) return ['f64.store', boxedAddr(arr), ptr]
+          if (isGlobal(arr)) return ['global.set', `$${arr}`, ptr]
+          return ['local.set', `$${arr}`, ptr]
+        }
+        return typed(['block', ['result', 'f64'],
+          ['local.set', `$${objTmp}`, asF64(va)],
+          ['local.set', `$${idxTmp}`, vi],
+          ['local.set', `$${t}`, vv],
+          ['if', ['result', 'f64'],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.ARRAY]],
+            ['then', ['block', ['result', 'f64'],
+              ['local.set', `$${ptrTmp}`, ['call', '$__arr_set_idx_ptr', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${t}`]]],
+              persist(['local.get', `$${ptrTmp}`]),
+              ['local.get', `$${t}`]]],
+            ['else', hasTypedSet ? ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.TYPED]],
+              ['then', ['call', '$__typed_set_idx', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], ['local.get', `$${idxTmp}`], ['local.get', `$${t}`]]],
+              ['else', ['block', ['result', 'f64'],
+                ['f64.store', ['i32.add', ptrOffsetIR(['local.get', `$${objTmp}`], arrVT), ['i32.shl', ['local.get', `$${idxTmp}`], ['i32.const', 3]]], ['local.get', `$${t}`]],
+                ['local.get', `$${t}`]]]] : ['block', ['result', 'f64'],
+              ['f64.store', ['i32.add', ptrOffsetIR(['local.get', `$${objTmp}`], arrVT), ['i32.shl', ['local.get', `$${idxTmp}`], ['i32.const', 3]]], ['local.get', `$${t}`]],
+              ['local.get', `$${t}`]]]]], 'f64')
+      }
       return typed(['block', ['result', 'f64'],
         ['local.set', `$${t}`, vv],
         ['f64.store', ['i32.add', ptrOffsetIR(asF64(va), arrVT), ['i32.shl', vi, ['i32.const', 3]]], ['local.get', `$${t}`]],
@@ -982,10 +1297,8 @@ export const emitter = {
     if (Array.isArray(name) && name[0] === '.') {
       const [, obj, prop] = name
       // Schema-based object → f64.store at fixed offset.
-      // safe=true: skip structural subtyping when variable's type is unknown,
-      // otherwise a slot write could clobber an array/string's payload.
       if (typeof obj === 'string' && ctx.schema.find) {
-        const idx = ctx.schema.find(obj, prop, true)
+        const idx = ctx.schema.find(obj, prop)
         if (idx >= 0) {
           const va = emit(obj), vv = asF64(emit(val)), t = temp()
           const shadow = needsDynShadow(obj)
@@ -995,39 +1308,60 @@ export const emitter = {
             ['f64.store', ['i32.add', ptrOffsetIR(asF64(va), lookupValType(obj) || VAL.OBJECT), ['i32.const', idx * 8]], ['local.get', `$${t}`]],
           ]
           if (shadow)
-            stmts.push(['drop', ['call', '$__dyn_set', asF64(va), asF64(emit(['str', prop])), ['local.get', `$${t}`]]])
+            stmts.push(['drop', ['call', '$__dyn_set', asI64(va), asI64(emit(['str', prop])), ['i64.reinterpret_f64', ['local.get', `$${t}`]]]])
           stmts.push(['local.get', `$${t}`])
           return typed(['block', ['result', 'f64'], ...stmts], 'f64')
         }
       }
       if (typeof obj === 'string') {
         const objType = keyValType(obj)
-        if (usesDynProps(objType)) {
+        // OBJECT receivers (incl. JSON.parse-derived bindings) with off-schema
+        // properties go through __dyn_set, which writes to the per-OBJECT
+        // propsPtr at off-16 — same path as object-literal dyn shadow writes
+        // (module/object.js). __hash_set assumes HASH bucket layout and would
+        // corrupt OBJECT memory.
+        if (usesDynProps(objType) || objType === VAL.OBJECT) {
+          inc('__dyn_set')
+          return typed(['f64.reinterpret_i64', ['call', '$__dyn_set', asI64(emit(obj)), asI64(emit(['str', prop])), asI64(emit(val))]], 'f64')
+        }
+        if (ctx.func.names.has(obj) && !ctx.func.locals?.has(obj) && !ctx.func.current?.params?.some(p => p.name === obj)) {
           inc('__dyn_set')
-          return typed(['call', '$__dyn_set', asF64(emit(obj)), asF64(emit(['str', prop])), asF64(emit(val))], 'f64')
+          return typed(['f64.reinterpret_i64', ['call', '$__dyn_set', asI64(emit(obj)), asI64(emit(['str', prop])), asI64(emit(val))]], 'f64')
+        }
+        if (objType == null && ctx.transform.host !== 'wasi') {
+          ctx.features.external = true
         }
-        if (objType == null) ctx.features.external = true
         inc('__hash_set')
-        const setCall = typed(['call', '$__hash_set', asF64(emit(obj)), asF64(emit(['str', prop])), asF64(emit(val))], 'f64')
+        const setCall = typed(['f64.reinterpret_i64', ['call', '$__hash_set', asI64(emit(obj)), asI64(emit(['str', prop])), asI64(emit(val))]], 'f64')
         if (isGlobal(obj)) return typed(['block', ['result', 'f64'],
           ['global.set', `$${obj}`, setCall], ['global.get', `$${obj}`]], 'f64')
+        // Closure-captured (boxed) locals store the value at the cell address — local.tee
+        // would write to the i32 cell pointer, not the f64 value. Route through writeVar.
+        if (ctx.func.boxed?.has(obj)) return writeVar(obj, setCall, false)
         return typed(['local.tee', `$${obj}`, setCall], 'f64')
       }
-      ctx.features.external = true
+      if (ctx.transform.host !== 'wasi') ctx.features.external = true
       inc('__dyn_set')
-      return typed(['call', '$__dyn_set', asF64(emit(obj)), asF64(emit(['str', prop])), asF64(emit(val))], 'f64')
+      return typed(['f64.reinterpret_i64', ['call', '$__dyn_set', asI64(emit(obj)), asI64(emit(['str', prop])), asI64(emit(val))]], 'f64')
     }
     if (typeof name !== 'string') err(`Assignment to non-variable: ${JSON.stringify(name)}`)
-    const void_ = _expect === 'void'
+    if (Array.isArray(val) && val[0] === 'u+' && val[1] === name) {
+      inc('__to_num')
+      return writeVar(name, typed(['call', '$__to_num', asI64(emit(name))], 'f64'), void_)
+    }
     return writeVar(name, emit(val), void_)
   },
 
   // Compound assignments: read-modify-write with type coercion
   '+=': (name, val) => {
-    // String concatenation: desugar to name = name + val (+ handler knows about strings)
+    // String concatenation: desugar to name = name + val (+ handler knows about strings).
+    // Also desugar when either side has unknown type — the `+` operator picks runtime
+    // string/numeric dispatch (`__is_str_key`); compoundAssign would force f64.add and
+    // silently corrupt string concatenations through unknown-typed values.
     const vt = typeof name === 'string' ? keyValType(name) : null
     const vtB = keyValType(val)
     if (vt === VAL.STRING || vtB === VAL.STRING) return emit(['=', name, ['+', name, val]])
+    if ((vt == null || vtB == null) && ctx.core.stdlib['__str_concat']) return emit(['=', name, ['+', name, val]])
     return compoundAssign(name, val, (a, b) => typed(['f64.add', a, b], 'f64'), (a, b) => typed(['i32.add', a, b], 'i32'))
   },
   ...Object.fromEntries([
@@ -1068,11 +1402,8 @@ export const emitter = {
     const t = temp()
     const va = readVar(name)
     // Condition: ||= → truthy check, &&= → truthy check, ??= → nullish check
-    const cond = op === '??='
-      ? isNullish(['local.tee', `$${t}`, asF64(va)])
-      : ['i32.and',
-          ['f64.eq', ['local.tee', `$${t}`, asF64(va)], ['local.get', `$${t}`]],
-          ['f64.ne', ['local.get', `$${t}`], ['f64.const', 0]]]
+    const lhs = typed(['local.tee', `$${t}`, asF64(va)], 'f64')
+    const cond = op === '??=' ? isNullish(lhs) : truthyIR(lhs)
     // &&= and ??= assign when cond is true (truthy / nullish); ||= assigns when cond is false
     const [thenExpr, elseExpr] = op === '||='
       ? [['local.get', `$${t}`], asF64(emit(val))]
@@ -1109,12 +1440,25 @@ export const emitter = {
     const vtA = keyValType(a)
     const vtB = keyValType(b)
     if (vtA === VAL.STRING && vtB === VAL.STRING) {
+      // Fused append-byte: `buf += s[i]` skips 1-char SSO construction +
+      // generic concat dispatch when rhs is a string-index. The byte flows
+      // straight from __char_at into memory, and the bump-extend path elides
+      // the alloc+copy when lhs is the heap-top STRING.
+      if (Array.isArray(b) && b[0] === '[]' && ctx.core.stdlib['__str_append_byte'] && ctx.core.stdlib['__char_at']) {
+        if (keyValType(b[1]) === VAL.STRING) {
+          inc('__str_append_byte', '__char_at')
+          return typed(['call', '$__str_append_byte',
+            asI64(emit(a)),
+            ['call', '$__char_at', asI64(emit(b[1])), asI32(emit(b[2]))],
+          ], 'f64')
+        }
+      }
       inc('__str_concat_raw')
-      return typed(['call', '$__str_concat_raw', asF64(emit(a)), asF64(emit(b))], 'f64')
+      return typed(['call', '$__str_concat_raw', asI64(emit(a)), asI64(emit(b))], 'f64')
     }
     if (vtA === VAL.STRING || vtB === VAL.STRING) {
       inc('__str_concat')
-      return typed(['call', '$__str_concat', asF64(emit(a)), asF64(emit(b))], 'f64')
+      return typed(['call', '$__str_concat', asI64(emit(a)), asI64(emit(b))], 'f64')
     }
     if (vtA === VAL.BIGINT || vtB === VAL.BIGINT)
       return fromI64(['i64.add', asI64(emit(a)), asI64(emit(b))])
@@ -1125,9 +1469,9 @@ export const emitter = {
     if ((vtA == null || vtB == null) && ctx.core.stdlib['__str_concat']) {
       const tA = temp('add'), tB = temp('add')
       inc('__str_concat', '__is_str_key')
-      const checkA = vtA == null ? ['call', '$__is_str_key', ['local.tee', `$${tA}`, asF64(emit(a))]] : null
-      const checkB = vtB == null ? ['call', '$__is_str_key', ['local.tee', `$${tB}`, asF64(emit(b))]] : null
-      const concat = ['call', '$__str_concat', ['local.get', `$${tA}`], ['local.get', `$${tB}`]]
+      const checkA = vtA == null ? ['call', '$__is_str_key', ['i64.reinterpret_f64', ['local.tee', `$${tA}`, asF64(emit(a))]]] : null
+      const checkB = vtB == null ? ['call', '$__is_str_key', ['i64.reinterpret_f64', ['local.tee', `$${tB}`, asF64(emit(b))]]] : null
+      const concat = ['call', '$__str_concat', ['i64.reinterpret_f64', ['local.get', `$${tA}`]], ['i64.reinterpret_f64', ['local.get', `$${tB}`]]]
       const add    = ['f64.add', ['local.get', `$${tA}`], ['local.get', `$${tB}`]]
       if (checkA && checkB) {
         return typed(['if', ['result', 'f64'], ['i32.or', checkA, checkB], ['then', concat], ['else', add]], 'f64')
@@ -1139,8 +1483,8 @@ export const emitter = {
         ['if', ['result', 'f64'], checkA ?? checkB, ['then', concat], ['else', add]]
       ], 'f64')
     }
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb)) return emitNum(litVal(va) + litVal(vb))
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a + b)
+    if (_f) return _f
     if (isLit(vb) && litVal(vb) === 0) return va
     if (isLit(va) && litVal(va) === 0) return vb
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.add', va, vb], 'i32')
@@ -1152,9 +1496,9 @@ export const emitter = {
       return b === undefined
         ? fromI64(['i64.sub', ['i64.const', 0], asI64(emit(a))])
         : fromI64(['i64.sub', asI64(emit(a)), asI64(emit(b))])
-    if (b === undefined) { const v = emit(a); return isLit(v) ? emitNum(-litVal(v)) : v.type === 'i32' ? typed(['i32.sub', typed(['i32.const', 0], 'i32'), v], 'i32') : typed(['f64.neg', toNumF64(a, v)], 'f64') }
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb)) return emitNum(litVal(va) - litVal(vb))
+    if (b === undefined) return emitNeg(a)
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a - b)
+    if (_f) return _f
     if (isLit(vb) && litVal(vb) === 0) return toNumF64(a, va)
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.sub', va, vb], 'i32')
     return typed(['f64.sub', toNumF64(a, va), toNumF64(b, vb)], 'f64')
@@ -1162,18 +1506,18 @@ export const emitter = {
   'u+': a => {
     if (valTypeOf(a) === VAL.BIGINT)
       return typed(['f64.convert_i64_s', asI64(emit(a))], 'f64')
+    const v = emit(a)
+    if (v.type === 'i32') return asF64(v)
+    if (valTypeOf(a) === VAL.NUMBER) return toNumF64(a, v)
     inc('__to_num')
-    return typed(['call', '$__to_num', asF64(emit(a))], 'f64')
-  },
-  'u-': a => {
-    if (valTypeOf(a) === VAL.BIGINT) return fromI64(['i64.sub', ['i64.const', 0], asI64(emit(a))])
-    const v = emit(a); return isLit(v) ? emitNum(-litVal(v)) : v.type === 'i32' ? typed(['i32.sub', typed(['i32.const', 0], 'i32'), v], 'i32') : typed(['f64.neg', toNumF64(a, v)], 'f64')
+    return typed(['call', '$__to_num', asI64(v)], 'f64')
   },
+  'u-': a => emitNeg(a),
   '*': (a, b) => {
     if (valTypeOf(a) === VAL.BIGINT || valTypeOf(b) === VAL.BIGINT)
       return fromI64(['i64.mul', asI64(emit(a)), asI64(emit(b))])
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb)) return emitNum(litVal(va) * litVal(vb))
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a * b)
+    if (_f) return _f
     if (isLit(vb) && litVal(vb) === 1) return toNumF64(a, va)
     if (isLit(va) && litVal(va) === 1) return toNumF64(b, vb)
     if (isLit(vb) && litVal(vb) === 0) return isLit(va) ? vb : typed(['block', ['result', vb.type], va, 'drop', vb], vb.type)
@@ -1184,23 +1528,24 @@ export const emitter = {
   '/': (a, b) => {
     if (valTypeOf(a) === VAL.BIGINT || valTypeOf(b) === VAL.BIGINT)
       return fromI64(['i64.div_s', asI64(emit(a)), asI64(emit(b))])
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb) && litVal(vb) !== 0) return emitNum(litVal(va) / litVal(vb))
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a / b, b => b !== 0)
+    if (_f) return _f
     if (isLit(vb) && litVal(vb) === 1) return toNumF64(a, va)
     return typed(['f64.div', toNumF64(a, va), toNumF64(b, vb)], 'f64')
   },
   '%': (a, b) => {
     if (valTypeOf(a) === VAL.BIGINT || valTypeOf(b) === VAL.BIGINT)
       return fromI64(['i64.rem_s', asI64(emit(a)), asI64(emit(b))])
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb) && litVal(vb) !== 0) return emitNum(litVal(va) % litVal(vb))
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a % b, b => b !== 0)
+    if (_f) return _f
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.rem_s', va, vb], 'i32')
     return f64rem(toNumF64(a, va), toNumF64(b, vb))
   },
-
   // === Comparisons (always i32 result) ===
 
   '==': (a, b) => {
+    const charCmp = emitSingleCharIndexCmp(a, b)
+    if (charCmp) return charCmp
     // JS loose nullish equality: x == null / x == undefined.
     // If the non-literal side has a known non-null VAL type, fold to 0.
     if (isNullishLit(a)) {
@@ -1215,11 +1560,13 @@ export const emitter = {
     const tc = emitTypeofCmp(a, b, 'eq'); if (tc) return tc
     const va = emit(a), vb = emit(b)
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.eq', va, vb], 'i32')
-    // Both sides known-pure NUMBER → f64.eq (skip __eq's pointer-identity/string path).
-    // valTypeOf handles literals/arithmetic exprs; lookupValType covers typed locals/params.
-    const vta = valTypeOf(a) ?? (typeof a === 'string' ? lookupValType(a) : null)
-    const vtb = valTypeOf(b) ?? (typeof b === 'string' ? lookupValType(b) : null)
-    if (vta === VAL.NUMBER && vtb === VAL.NUMBER) return typed(['f64.eq', asF64(va), asF64(vb)], 'i32')
+    // Either side known-pure NUMBER (literal or typed) → f64.eq is correct regardless
+    // of the other side: jz's `==` is strict (prepare.js:868), and every NaN-boxed pointer
+    // reinterprets to a quiet NaN (0x7FF8… prefix) so f64.eq with any normal float is false.
+    // Catches `closureVar === 34` in jzified hot loops where the unknown side has no VAL.
+    const vta = resolveValType(a, valTypeOf, lookupValType)
+    const vtb = resolveValType(b, valTypeOf, lookupValType)
+    if (vta === VAL.NUMBER || vtb === VAL.NUMBER) return typed(['f64.eq', asF64(va), asF64(vb)], 'i32')
     // Reference-equal pointer kinds (same kind, non-STRING, non-BIGINT): i64 bit equality.
     // JS `==` on objects/arrays/sets/maps/etc. is pure reference equality — no content path.
     // STRING needs __eq (heap strings can be equal by content but different pointers).
@@ -1228,9 +1575,11 @@ export const emitter = {
       return typed(['i64.eq', ['i64.reinterpret_f64', asF64(va)], ['i64.reinterpret_f64', asF64(vb)]], 'i32')
     }
     inc('__eq')
-    return typed(['call', '$__eq', asF64(va), asF64(vb)], 'i32')
+    return typed(['call', '$__eq', asI64(va), asI64(vb)], 'i32')
   },
   '!=': (a, b) => {
+    const charCmp = emitSingleCharIndexCmp(a, b, true)
+    if (charCmp) return charCmp
     if (isNullishLit(a)) {
       if (valTypeOf(b)) return emitNum(1)
       return typed(['i32.eqz', isNullish(asF64(emit(b)))], 'i32')
@@ -1242,14 +1591,14 @@ export const emitter = {
     const tc = emitTypeofCmp(a, b, 'ne'); if (tc) return tc
     const va = emit(a), vb = emit(b)
     if (va.type === 'i32' && vb.type === 'i32') return typed(['i32.ne', va, vb], 'i32')
-    const vta = valTypeOf(a) ?? (typeof a === 'string' ? lookupValType(a) : null)
-    const vtb = valTypeOf(b) ?? (typeof b === 'string' ? lookupValType(b) : null)
-    if (vta === VAL.NUMBER && vtb === VAL.NUMBER) return typed(['f64.ne', asF64(va), asF64(vb)], 'i32')
+    const vta = resolveValType(a, valTypeOf, lookupValType)
+    const vtb = resolveValType(b, valTypeOf, lookupValType)
+    if (vta === VAL.NUMBER || vtb === VAL.NUMBER) return typed(['f64.ne', asF64(va), asF64(vb)], 'i32')
     if (vta && vta === vtb && REF_EQ_KINDS.has(vta)) {
       return typed(['i64.ne', ['i64.reinterpret_f64', asF64(va)], ['i64.reinterpret_f64', asF64(vb)]], 'i32')
     }
     inc('__eq')
-    return typed(['i32.eqz', ['call', '$__eq', asF64(va), asF64(vb)]], 'i32')
+    return typed(['i32.eqz', ['call', '$__eq', asI64(va), asI64(vb)]], 'i32')
   },
   '<':  cmpOp('lt_s', 'lt', (a, b) => a < b),
   '>':  cmpOp('gt_s', 'gt', (a, b) => a > b),
@@ -1264,13 +1613,13 @@ export const emitter = {
     // Unboxed pointer offsets: falsy iff zero offset.
     if (v.ptrKind != null) return typed(['i32.eqz', v], 'i32')
     // Known pointer-kinded operand: `!x` is just `x is nullish` (null/undefined).
-    // Pointers are never 0 / NaN / false / empty-string in the boxed form.
-    const vt = valTypeOf(a) ?? (typeof a === 'string' ? lookupValType(a) : null)
-    if (vt && vt !== VAL.NUMBER && vt !== VAL.BIGINT) {
+    // Excludes STRING — empty string '' is a valid (non-null) pointer but is falsy.
+    const vt = resolveValType(a, valTypeOf, lookupValType)
+    if (vt && vt !== VAL.NUMBER && vt !== VAL.BIGINT && vt !== VAL.STRING) {
       return isNullish(asF64(v))
     }
     inc('__is_truthy')
-    return typed(['i32.eqz', ['call', '$__is_truthy', asF64(v)]], 'i32')
+    return typed(['i32.eqz', ['call', '$__is_truthy', asI64(v)]], 'i32')
   },
 
   '?:': (a, b, c) => {
@@ -1311,7 +1660,21 @@ export const emitter = {
       }
     }
     const fb = asF64(vb), fc = asF64(vc)
-    if (isPureIR(fb) && isPureIR(fc))
+    const vtb = resolveValType(b, valTypeOf, lookupValType)
+    const vtc = resolveValType(c, valTypeOf, lookupValType)
+    const isNaNBoxLit = n => Array.isArray(n) && n[0] === 'f64.const' && typeof n[1] === 'string' && n[1].startsWith('nan:')
+    const refPayload = (vtb && vtb === vtc && REF_EQ_KINDS.has(vtb))
+      || vb.closureFuncIdx != null || vc.closureFuncIdx != null
+      || isNaNBoxLit(fb) || isNaNBoxLit(fc)
+    if (refPayload) {
+      const ib = ['i64.reinterpret_f64', fb]
+      const ic = ['i64.reinterpret_f64', fc]
+      const bits = isPureIR(fb) && isPureIR(fc)
+        ? ['select', ib, ic, cond]
+        : ['if', ['result', 'i64'], cond, ['then', ib], ['else', ic]]
+      return typed(['f64.reinterpret_i64', bits], 'f64')
+    }
+    if (!refPayload && isPureIR(fb) && isPureIR(fc))
       return typed(['select', fb, fc, cond], 'f64')
     return typed(['if', ['result', 'f64'], cond, ['then', fb], ['else', fc]], 'f64')
   },
@@ -1397,7 +1760,11 @@ export const emitter = {
 
   // === Bitwise (i32 for numbers, i64 for BigInt) ===
 
-  '~':   a => { const v = emit(a); return isLit(v) ? emitNum(~litVal(v)) : typed(['i32.xor', toI32(v), typed(['i32.const', -1], 'i32')], 'i32') },
+  // Per ECMAScript ToInt32, bitwise ops first ToNumber-coerce non-numeric operands.
+  // i32 / lit values are already numeric — the toNumF64 wrap is skipped to keep
+  // the numeric fast path at one wasm instruction. Non-numeric (NaN-boxed string,
+  // unknown type) routes through __to_num so "2026" | 0 === 2026.
+  '~':   a => { const v = emit(a); return isLit(v) ? emitNum(~litVal(v)) : typed(['i32.xor', toI32(v.type === 'i32' ? v : toNumF64(a, v)), typed(['i32.const', -1], 'i32')], 'i32') },
   ...Object.fromEntries([
     ['&', 'and'], ['|', 'or'], ['^', 'xor'], ['<<', 'shl'], ['>>', 'shr_s'],
   ].map(([op, fn]) => [op, (a, b) => {
@@ -1410,16 +1777,20 @@ export const emitter = {
       if (op === '^') return emitNum(la ^ lb); if (op === '<<') return emitNum(la << lb)
       if (op === '>>') return emitNum(la >> lb)
     }
-    return typed([`i32.${fn}`, toI32(va), toI32(vb)], 'i32')
+    const ca = va.type === 'i32' || isLit(va) ? va : toNumF64(a, va)
+    const cb = vb.type === 'i32' || isLit(vb) ? vb : toNumF64(b, vb)
+    return typed([`i32.${fn}`, toI32(ca), toI32(cb)], 'i32')
   }])),
   '>>>': (a, b) => {
-    const va = emit(a), vb = emit(b)
-    if (isLit(va) && isLit(vb)) return emitNum(litVal(va) >>> litVal(vb))
+    const va = emit(a), vb = emit(b), _f = foldConst(va, vb, (a, b) => a >>> b)
+    if (_f) return _f
     // F: Mark unsigned so `asF64` lifts via `f64.convert_i32_u` (preserving the
     // [0, 2^32) value range). Without this, `(s >>> 0) / 4294967296` would convert
     // signed for negative-high-bit s values, flipping sign and breaking the
     // canonical "uint32 → f64" idiom used in PRNGs and bit-manipulation code.
-    const node = typed(['i32.shr_u', toI32(va), toI32(vb)], 'i32')
+    const ca = va.type === 'i32' || isLit(va) ? va : toNumF64(a, va)
+    const cb = vb.type === 'i32' || isLit(vb) ? vb : toNumF64(b, vb)
+    const node = typed(['i32.shr_u', toI32(ca), toI32(cb)], 'i32')
     node.unsigned = true
     return node
   },
@@ -1547,6 +1918,8 @@ export const emitter = {
     let argList = Array.isArray(callArgs)
       ? (callArgs[0] === ',' ? callArgs.slice(1) : [callArgs])
       : callArgs ? [callArgs] : []
+    // Trailing comma in call: parser emits a trailing null sentinel — drop it
+    while (argList.length && argList[argList.length - 1] == null) argList.pop()
 
     // Helper: expand spread arguments into flat list of normal arguments + spread markers
     // Returns { normal: [...], spreads: [(pos, expr), ...] }
@@ -1566,6 +1939,26 @@ export const emitter = {
 
     const parsed = parseArgs(argList)
 
+    // Optional method call: obj?.method(args) — null if obj is nullish, else
+    // obj.method(args). The parser shapes this as ['()', ['?.', obj, method], args],
+    // distinct from the regular method call's ['.', obj, method] callee. Receiver
+    // hoists into a temp so the nullish check and the method dispatch below see
+    // the same evaluation; recursion with a synthetic '.'-callee reuses the type-
+    // aware method-dispatch in this same handler rather than duplicating it.
+    if (Array.isArray(callee) && callee[0] === '?.') {
+      const [, obj, method] = callee
+      const t = `${T}om${ctx.func.uniq++}`
+      ctx.func.locals.set(t, 'f64')
+      const va = asF64(emit(obj))
+      const methodCall = emitter['()'](['.', t, method], callArgs)
+      return typed(['block', ['result', 'f64'],
+        ['local.set', `$${t}`, va],
+        ['if', ['result', 'f64'],
+          ['i32.eqz', isNullish(typed(['local.get', `$${t}`], 'f64'))],
+          ['then', asF64(methodCall)],
+          ['else', nullExpr()]]], 'f64')
+    }
+
     // Method call: obj.method(args) → type-aware dispatch
     if (Array.isArray(callee) && callee[0] === '.') {
       const [, obj, method] = callee
@@ -1577,7 +1970,7 @@ export const emitter = {
           const func = ctx.func.map.get(fname)
           const emittedArgs = parsed.normal.map((a, k) => emitArgForParam(emit(a), func.sig.params[k]))
           while (emittedArgs.length < func.sig.params.length)
-            emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : nullExpr())
+            emittedArgs.push(func.sig.params[emittedArgs.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : undefExpr())
           const callIR = typed(['call', `$${fname}`, ...emittedArgs], func.sig.results[0])
           if (func.sig.ptrKind != null) callIR.ptrKind = func.sig.ptrKind
           if (func.sig.ptrAux != null) callIR.ptrAux = func.sig.ptrAux
@@ -1585,7 +1978,10 @@ export const emitter = {
         }
       }
 
-      const vt = keyValType(obj)
+      let vt = keyValType(obj)
+      if (typeof obj === 'string' && isReassigned(ctx.func.body, obj)
+        && (method === 'slice' || method === 'concat')
+        && vt !== VAL.STRING && vt !== VAL.ARRAY) vt = null
 
       // Helper to call method with arguments (handles spread expansion)
       const callMethod = (objArg, methodEmitter) => {
@@ -1624,23 +2020,23 @@ export const emitter = {
           ir.push(['local.set', `$${o}`, asF64(emit(objArg))])
           ir.push(['local.set', `$${sa}`, n ? materializeMulti(spreadExpr) : asF64(emit(spreadExpr))])
           if (srcIsArr) {
-            ir.push(['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['local.get', `$${sa}`]]])
+            ir.push(['local.set', `$${srcBase}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${sa}`]]]])
             ir.push(['local.set', `$${sl}`, ['i32.load', ['i32.sub', ['local.get', `$${srcBase}`], ['i32.const', 8]]]])
           } else {
-            ir.push(['local.set', `$${sl}`, ['call', '$__len', ['local.get', `$${sa}`]]])
+            ir.push(['local.set', `$${sl}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${sa}`]]]])
           }
           // Old length: inline as `i32.load (off-8)` if obj is known ARRAY (matches .push handler).
           if (objIsArr) {
             ir.push(['local.set', `$${ol}`,
-              ['i32.load', ['i32.sub', ['call', '$__ptr_offset', ['local.get', `$${o}`]], ['i32.const', 8]]]])
+              ['i32.load', ['i32.sub', ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${o}`]]], ['i32.const', 8]]]])
           } else {
-            ir.push(['local.set', `$${ol}`, ['call', '$__len', ['local.get', `$${o}`]]])
+            ir.push(['local.set', `$${ol}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${o}`]]]])
           }
           // Single grow for the full spread (vs per-element grow check in the generic loop).
-          ir.push(['local.set', `$${o}`, ['call', '$__arr_grow', ['local.get', `$${o}`],
+          ir.push(['local.set', `$${o}`, ['call', '$__arr_grow', ['i64.reinterpret_f64', ['local.get', `$${o}`]],
             ['i32.add', ['local.get', `$${ol}`], ['local.get', `$${sl}`]]]])
           // base captured AFTER grow (grow may relocate the array).
-          ir.push(['local.set', `$${base}`, ['call', '$__ptr_offset', ['local.get', `$${o}`]]])
+          ir.push(['local.set', `$${base}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${o}`]]]])
           // Tight store loop.
           ir.push(['local.set', `$${si}`, ['i32.const', 0]])
           const loopId = ctx.func.uniq++
@@ -1656,7 +2052,7 @@ export const emitter = {
             ['local.set', `$${si}`, ['i32.add', ['local.get', `$${si}`], ['i32.const', 1]]],
             ['br', `$continue${loopId}`]]])
           // Single set_len for the full spread.
-          ir.push(['call', '$__set_len', ['local.get', `$${o}`],
+          ir.push(['call', '$__set_len', ['i64.reinterpret_f64', ['local.get', `$${o}`]],
             ['i32.add', ['local.get', `$${ol}`], ['local.get', `$${sl}`]]])
           // Update source variable: grow may have moved the pointer.
           if (ctx.func.boxed?.has(objArg)) {
@@ -1694,7 +2090,7 @@ export const emitter = {
           inc('__len')
           const n = multiCount(spreadExpr)
           ir.push(['local.set', `$${arr}`, n ? materializeMulti(spreadExpr) : asF64(emit(spreadExpr))])
-          ir.push(['local.set', `$${len}`, ['call', '$__len', ['local.get', `$${arr}`]]])
+          ir.push(['local.set', `$${len}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arr}`]]]])
           ir.push(['local.set', `$${idx}`,
             reverseIter ? ['i32.sub', ['local.get', `$${len}`], ['i32.const', 1]] : ['i32.const', 0]])
           const loopId = ctx.func.uniq++
@@ -1745,7 +2141,7 @@ export const emitter = {
               const n = multiCount(spreadExpr)
               irG.push(
                 ['local.set', `$${arrL}`, n ? materializeMulti(spreadExpr) : asF64(emit(spreadExpr))],
-                ['local.set', `$${lenL}`, ['call', '$__len', ['local.get', `$${arrL}`]]],
+                ['local.set', `$${lenL}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]]],
                 ['local.set', `$${idxL}`, ['i32.const', 0]])
               const loopId = ctx.func.uniq++
               const loopBody = asF64(methodEmitter(objArg, ['[]', arrL, idxL]))
@@ -1784,7 +2180,7 @@ export const emitter = {
             const n = multiCount(spreadExpr)
             irG.push(
               ['local.set', `$${arrL}`, n ? materializeMulti(spreadExpr) : asF64(emit(spreadExpr))],
-              ['local.set', `$${lenL}`, ['call', '$__len', ['local.get', `$${arrL}`]]],
+              ['local.set', `$${lenL}`, ['call', '$__len', ['i64.reinterpret_f64', ['local.get', `$${arrL}`]]]],
               ['local.set', `$${idxL}`, ['i32.const', 0]])
             const loopId = ctx.func.uniq++
             const loopBody = asF64(methodEmitter(accG, ['[]', arrL, idxL]))
@@ -1845,15 +2241,26 @@ export const emitter = {
         const genEmitter = ctx.core.emit[genKey]
         return typed(['block', ['result', 'f64'],
           ['local.set', `$${t}`, asF64(emit(obj))],
-          ['local.set', `$${tt}`, ['call', '$__ptr_type', ['local.get', `$${t}`]]],
+          ['local.set', `$${tt}`, ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${t}`]]]],
           ['if', ['result', 'f64'],
-            ['i32.or',
-              ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.STRING]],
-              ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.SSO]]],
+            ['i32.eq', ['local.get', `$${tt}`], ['i32.const', PTR.STRING]],
             ['then', callMethod(t, strEmitter)],
             ['else', callMethod(t, genEmitter)]]], 'f64')
       }
 
+      // Schema property function call: x.prop(args) where prop is a closure in boxed schema
+      if (typeof obj === 'string' && ctx.schema.find && ctx.closure.call) {
+        const idx = ctx.schema.find(obj, method)
+        if (idx >= 0 && !ctx.schema.isBoxed?.(obj)) {
+          const propRead = typed(['f64.load', ['i32.add', ptrOffsetIR(asF64(emit(obj)), lookupValType(obj) || VAL.OBJECT), ['i32.const', idx * 8]]], 'f64')
+          if (parsed.hasSpread) {
+            const combined = reconstructArgsWithSpreads(parsed.normal, parsed.spreads)
+            return ctx.closure.call(propRead, [buildArrayWithSpreads(combined)], true)
+          }
+          return ctx.closure.call(propRead, parsed.normal)
+        }
+      }
+
       // Schema property function call: x.prop(args) where prop is a closure in boxed schema
       if (typeof obj === 'string' && ctx.schema.find && ctx.closure.call && ctx.schema.isBoxed?.(obj)) {
         const idx = ctx.schema.find(obj, method)
@@ -1876,7 +2283,7 @@ export const emitter = {
         ctx.func.locals.set(objTmp, 'f64')
         const combined = reconstructArgsWithSpreads(parsed.normal, parsed.spreads)
         const arrayIR = buildArrayWithSpreads(combined)
-        const propRead = typed(['call', '$__dyn_get_expr', ['local.get', `$${objTmp}`], asF64(emit(['str', method]))], 'f64')
+        const propRead = typed(['f64.reinterpret_i64', ['call', '$__dyn_get_expr', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]], asI64(emit(['str', method]))]], 'f64')
         const propTmp = `${T}mprop${ctx.func.uniq++}`
         ctx.func.locals.set(propTmp, 'f64')
         if (usesDynProps(vt)) {
@@ -1885,7 +2292,18 @@ export const emitter = {
             ['local.set', `$${objTmp}`, asF64(emit(obj))],
             ['local.set', `$${propTmp}`, propRead],
             ['if', ['result', 'f64'],
-              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${propTmp}`]], ['i32.const', PTR.CLOSURE]],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${propTmp}`]]], ['i32.const', PTR.CLOSURE]],
+              ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [arrayIR], true)],
+              ['else', undefExpr()]]], 'f64')
+        }
+        // WASI: no PTR.EXTERNAL values; closure-only dispatch is correct.
+        if (ctx.transform.host === 'wasi') {
+          inc('__dyn_get_expr', '__ptr_type')
+          return typed(['block', ['result', 'f64'],
+            ['local.set', `$${objTmp}`, asF64(emit(obj))],
+            ['local.set', `$${propTmp}`, propRead],
+            ['if', ['result', 'f64'],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${propTmp}`]]], ['i32.const', PTR.CLOSURE]],
               ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [arrayIR], true)],
               ['else', undefExpr()]]], 'f64')
         }
@@ -1895,22 +2313,29 @@ export const emitter = {
           ['local.set', `$${objTmp}`, asF64(emit(obj))],
           ['local.set', `$${propTmp}`, propRead],
           ['if', ['result', 'f64'],
-            ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${propTmp}`]], ['i32.const', PTR.CLOSURE]],
+            ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${propTmp}`]]], ['i32.const', PTR.CLOSURE]],
             ['then', ctx.closure.call(typed(['local.get', `$${propTmp}`], 'f64'), [arrayIR], true)],
             ['else', ['if', ['result', 'f64'],
-              ['i32.eq', ['call', '$__ptr_type', ['local.get', `$${objTmp}`]], ['i32.const', PTR.EXTERNAL]],
-              ['then', ['call', '$__ext_call', ['local.get', `$${objTmp}`], asF64(emit(['str', method])), arrayIR]],
+              ['i32.eq', ['call', '$__ptr_type', ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]]], ['i32.const', PTR.EXTERNAL]],
+              ['then', ['f64.reinterpret_i64', ['call', '$__ext_call',
+                ['i64.reinterpret_f64', ['local.get', `$${objTmp}`]],
+                ['i64.reinterpret_f64', asF64(emit(['str', method]))],
+                ['i64.reinterpret_f64', arrayIR]]]],
               ['else', undefExpr()]]]]], 'f64')
       }
 
       // Unknown callee - assume external method
       if (ctx.transform.strict)
         err(`strict mode: method call \`${typeof obj === 'string' ? obj : '<expr>'}.${method}(...)\` on a value of unknown type falls through to host \`__ext_call\`. Annotate the receiver type or pass { strict: false }.`)
+      if (ctx.transform.host === 'wasi') return undefExpr()
       inc('__ext_call')
       ctx.features.external = true
       const combined = reconstructArgsWithSpreads(parsed.normal, parsed.spreads)
       const arrayIR = buildArrayWithSpreads(combined)
-      return typed(['call', '$__ext_call', asF64(emit(obj)), asF64(emit(['str', method])), arrayIR], 'f64');
+      return typed(['f64.reinterpret_i64', ['call', '$__ext_call',
+        ['i64.reinterpret_f64', asF64(emit(obj))],
+        ['i64.reinterpret_f64', asF64(emit(['str', method]))],
+        ['i64.reinterpret_f64', arrayIR]]], 'f64');
     }
 
     if (ctx.core.emit[callee]) {
@@ -1929,17 +2354,17 @@ export const emitter = {
     }
 
     // Direct call if callee is a known top-level function
-    if (typeof callee === 'string' && ctx.func.names.has(callee)) {
+    if (typeof callee === 'string' && ctx.func.names.has(callee) && !ctx.func.locals?.has(callee)) {
       const func = ctx.func.map.get(callee)
 
       // Rest param case: collect all args (including expanded spreads) into array
       if (func?.rest) {
         const fixedParamCount = func.sig.params.length - 1
         const fixedArgs = parsed.normal.slice(0, fixedParamCount)
-        // Pad missing fixed args with sentinel for defaults
+        // Pad missing fixed args with `undefined` so default-param init triggers per spec.
         const emittedFixed = fixedArgs.map((a, k) => emitArgForParam(emit(a), func.sig.params[k]))
         while (emittedFixed.length < fixedParamCount)
-          emittedFixed.push(func.sig.params[emittedFixed.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : nullExpr())
+          emittedFixed.push(func.sig.params[emittedFixed.length].type === 'i32' ? typed(['i32.const', 0], 'i32') : undefExpr())
 
         // Reconstruct with spreads, then take rest args
         const combined = reconstructArgsWithSpreads(parsed.normal, parsed.spreads)
@@ -1957,10 +2382,16 @@ export const emitter = {
 
       // Regular function call without rest params
       if (parsed.hasSpread) err(`Spread not supported in calls to non-variadic function ${callee}`)
-      // Pad missing args with canonical NaN (triggers default param init)
+      // Pad missing args with `undefined` so default-param init triggers per spec
+      // (only undefined, not null, should trigger defaults). Drop extras to match
+      // JS calling convention — emitting them anyway produces an invalid call
+      // when the callee is a fixed-arity import (e.g. `_interp`-registered host
+      // stubs) since wasm validates arg count. Use ?? rather than || so a
+      // legitimate 0-arity callee isn't bypassed.
       const args = parsed.normal.map((a, k) => emitArgForParam(emit(a), func?.sig.params[k]))
-      const expected = func?.sig.params.length || args.length
-      while (args.length < expected) args.push(func?.sig.params[args.length]?.type === 'i32' ? typed(['i32.const', 0], 'i32') : nullExpr())
+      const expected = func?.sig.params.length ?? args.length
+      while (args.length < expected) args.push(func?.sig.params[args.length]?.type === 'i32' ? typed(['i32.const', 0], 'i32') : undefExpr())
+      if (args.length > expected) args.length = expected
       // Multi-value return: materialize as heap array (caller expects single pointer)
       if (func?.sig.results.length > 1) return materializeMulti(['()', callee, ...parsed.normal])
       const callIR = typed(['call', `$${callee}`, ...args], func?.sig.results[0] || 'f64')
@@ -2001,13 +2432,80 @@ export const emitter = {
       return ctx.closure.call(emit(callee), parsed.normal)
     }
 
-    // Unknown callee — assume direct call
-    return typed(['call', `$${callee}`, ...argList.map(a => asF64(emit(a)))], 'f64')
+    // Unknown callee — assume direct call. Match arg count to the declared
+    // signature when the callee is a registered env import (e.g. `_interp`-
+    // wired host stubs). JS calling convention drops extras and pads missing;
+    // wasm requires exact arity, so emitting raw argList against a fixed-arity
+    // import would invalidate the module.
+    let calleeArity = null
+    if (typeof callee === 'string') {
+      const imp = ctx.module.imports?.find(i =>
+        Array.isArray(i) && i[0] === 'import' && i[3]?.[0] === 'func' && i[3]?.[1] === `$${callee}`)
+      if (imp) {
+        let n = 0
+        for (let k = 2; k < imp[3].length; k++) if (Array.isArray(imp[3][k]) && imp[3][k][0] === 'param') n++
+        calleeArity = n
+      }
+    }
+    const emittedArgs = argList.map(a => asF64(emit(a)))
+    if (calleeArity != null) {
+      while (emittedArgs.length < calleeArity) emittedArgs.push(undefExpr())
+      if (emittedArgs.length > calleeArity) emittedArgs.length = calleeArity
+    }
+    return typed(['call', `$${callee}`, ...emittedArgs], 'f64')
   },
 }
 
 // === Emit dispatch ===
 
+// Optional-chain continuation: `a?.b.c` → if `a` nullish then undefined, else `a.b.c`.
+// Per ECMAScript, an optional access short-circuits the entire continuation, not just
+// its own access. Without this, `a?.b.c` parses as `(a?.b).c` and `.c` runs on the
+// nullish result of `a?.b`, returning a wrong value (or trapping in typed lowerings).
+//
+// At the outermost `.` / `[]` / `()` whose leftmost descent contains an optional, hoist
+// the deepest such optional's head into a temp, nullish-guard, and rebuild the chain
+// with that optional replaced by a regular access. The single guard short-circuits the
+// whole continuation. Nested optionals further inside the chain are left intact and
+// handle their own short-circuiting on recursion.
+function liftOptionalChain(node) {
+  const path = []
+  let cur = node
+  while (Array.isArray(cur) && (cur[0] === '.' || cur[0] === '[]' || cur[0] === '()' ||
+                                 cur[0] === '?.' || cur[0] === '?.[]' || cur[0] === '?.()')) {
+    path.push(cur)
+    cur = cur[1]
+  }
+  // Find the deepest optional with continuation outside it. optIdx === 0 means the
+  // chain root itself is optional with no continuation — handled by the regular
+  // `?.` / `?.[]` / `?.()` emitters.
+  let optIdx = -1
+  for (let i = path.length - 1; i >= 1; i--) {
+    if (path[i][0] === '?.' || path[i][0] === '?.[]' || path[i][0] === '?.()') {
+      optIdx = i
+      break
+    }
+  }
+  if (optIdx <= 0) return null
+  const opt = path[optIdx]
+  const headExpr = opt[1]
+  const t = temp('oc')
+  let rebuilt
+  if (opt[0] === '?.') rebuilt = ['.', t, opt[2]]
+  else if (opt[0] === '?.[]') rebuilt = ['[]', t, opt[2]]
+  else rebuilt = ['()', t, ...opt.slice(2)]
+  for (let i = optIdx - 1; i >= 0; i--) {
+    const outer = path[i]
+    rebuilt = [outer[0], rebuilt, ...outer.slice(2)]
+  }
+  return typed(['block', ['result', 'f64'],
+    ['local.set', `$${t}`, asF64(emit(headExpr))],
+    ['if', ['result', 'f64'],
+      ['i32.eqz', isNullish(typed(['local.get', `$${t}`], 'f64'))],
+      ['then', asF64(emit(rebuilt))],
+      ['else', undefExpr()]]], 'f64')
+}
+
 /**
  * Emit single AST node to typed WASM IR.
  * Every returned node has .type = 'i32' | 'f64'.
@@ -2028,14 +2526,10 @@ export function emit(node, expect) {
     const n = node & 0xFFFFFFFFFFFFFFFFn
     return typed(['f64.reinterpret_i64', ['i64.const', '0x' + n.toString(16)]], 'f64')
   }
-  if (typeof node === 'number') {
-    if (Number.isInteger(node) && node >= -2147483648 && node <= 2147483647)
-      return typed(['i32.const', node], 'i32')
-    return typed(['f64.const', node], 'f64')
-  }
+  if (typeof node === 'number') return emitNum(node)
   if (typeof node === 'string') {
     // Variable read: boxed / local / param / global (check before emitter table to avoid name collisions)
-    if (ctx.func.boxed?.has(node) || ctx.func.locals?.has(node) || ctx.func.current?.params?.some(p => p.name === node) || isGlobal(node))
+    if (ctx.func.boxed?.has(node) || ctx.func.locals?.has(node) || ctx.func.current?.params?.some(p => p.name === node) || isGlobal(node) || repOf(node)?.intConst != null)
       return readVar(node)
     // Top-level function used as value → wrap as closure pointer for call_indirect
     if (ctx.func.names.has(node) && !ctx.func.locals?.has(node) && !ctx.func.current?.params?.some(p => p.name === node) && ctx.closure.table) {
@@ -2072,17 +2566,28 @@ export function emit(node, expect) {
       }
       let idx = ctx.closure.table.indexOf(trampolineName)
       if (idx < 0) { idx = ctx.closure.table.length; ctx.closure.table.push(trampolineName) }
-      return mkPtrIR(PTR.CLOSURE, idx, 0)
+      const ir = mkPtrIR(PTR.CLOSURE, idx, 0)
+      ir.closureFuncIdx = idx
+      return ir
     }
     // Emitter table: only namespace-resolved names (contain '.', e.g. 'math.PI') — safe from user variable collision
-    if (node.includes('.') && ctx.core.emit[node]) return ctx.core.emit[node]()
+    if (node.includes('.') && ctx.core.emit[node]) {
+      const handler = ctx.core.emit[node]
+      return handler.length > 0 ? builtinFunctionValue(node) : handler()
+    }
     // Auto-import known host globals (WebAssembly, globalThis, etc.)
     const HOST_GLOBALS = new Set(['WebAssembly', 'globalThis', 'self', 'window', 'global', 'process'])
     if (HOST_GLOBALS.has(node) && !ctx.func.locals?.has(node) && !ctx.func.current?.params?.some(p => p.name === node) && !isGlobal(node)) {
+      if (ctx.transform.host === 'wasi') err(`host:'wasi': reference to host global \`${node}\` requires an env import. Remove the reference or use host:'js'.`)
       ctx.features.external = true
       ctx.scope.globals.set(node, null)
-      ctx.module.imports.push(['import', '"env"', `"${node}"`, ['global', `$${node}`, ['mut', 'f64']]])
-      return typed(['global.get', `$${node}`], 'f64')
+      // Carrier is i64 (not f64) so V8 can't canonicalize the NaN-boxed
+      // external-ref payload across the wasm↔JS global boundary (same hazard
+      // as env.print/setTimeout — see module/console.js header). asF64()
+      // reinterprets to f64 at every read site.
+      ctx.module.imports.push(['import', '"env"', `"${node}"`, ['global', `$${node}`, 'i64']])
+      ctx.scope.globalTypes.set(node, 'i64')
+      return typed(['global.get', `$${node}`], 'i64')
     }
     const t = ctx.func.locals?.get(node) || ctx.func.current?.params.find(p => p.name === node)?.type || 'f64'
     return typed(['local.get', `$${node}`], t)
@@ -2099,6 +2604,14 @@ export function emit(node, expect) {
     return v === undefined ? undefExpr() : v === null ? nullExpr() : emit(v)
   }
 
+  // Optional-chain continuation: `a?.b.c` → if `a` nullish then undefined else `a.b.c`.
+  // Lift before dispatch so the regular `.` / `[]` / `()` handler sees the rebuilt chain
+  // with the optional already replaced by a non-optional access on a guarded temp.
+  if (op === '.' || op === '[]' || op === '()') {
+    const lifted = liftOptionalChain(node)
+    if (lifted) return lifted
+  }
+
   const handler = ctx.core.emit[op]
   if (!handler) err(`Unknown op: ${op}`)
   return handler(...args)