jz 0.1.1 → 0.2.1

package/src/ir.js

@@ -20,7 +20,7 @@
  * @module ir
  */
 
-import { ctx, err, inc, PTR } from './ctx.js'
+import { ctx, err, inc, PTR, LAYOUT } from './ctx.js'
 import { T, VAL, valTypeOf, lookupValType, repOf, repOfGlobal } from './analyze.js'
 
 // === Type helpers ===
@@ -49,8 +49,10 @@ function boxPtrIR(i32node, ptrType, aux = 0) {
  *  The `unsigned` flag (set by `>>>` codegen) opts into `convert_i32_u` so the canonical
  *  `(x >>> 0)` uint32 idiom converts to a positive f64 in [0, 2^32) instead of sign-flipping. */
 export const asF64 = n => {
+  if (n == null) err(`compiler internal: expected emitted IR value in ${ctx.func.current?.name || '<module>'}, got empty value`)
   if (n.ptrKind != null) return boxPtrIR(n, valKindToPtr(n.ptrKind), n.ptrAux || 0)
   if (n.type === 'f64') return n
+  if (n.type === 'i64') return typed(['f64.reinterpret_i64', n], 'f64')
   if (n[0] === 'i32.const' && typeof n[1] === 'number') return typed(['f64.const', n[1]], 'f64')
   return typed([n.unsigned ? 'f64.convert_i32_u' : 'f64.convert_i32_s', n], 'f64')
 }
@@ -73,8 +75,8 @@ export const asI32 = n => {
 export const asPtrOffset = (n, ptrKind) =>
   n.ptrKind === ptrKind ? n : typed(['i32.wrap_i64', ['i64.reinterpret_f64', asF64(n)]], 'i32')
 
-/** Coerce emitted IR to a target WASM param type ('i32' | 'f64'). */
-export const asParamType = (n, t) => t === 'i32' ? asI32(n) : asF64(n)
+/** Coerce emitted IR to a target WASM param type ('i32' | 'i64' | 'f64'). */
+export const asParamType = (n, t) => t === 'i32' ? asI32(n) : t === 'i64' ? asI64(n) : asF64(n)
 
 /** Coerce node to i32 with wrapping (JS `|0` semantics: values > 2^31 wrap to negative).
  *  Per ECMAScript ToInt32, NaN and ±∞ map to 0. `i64.trunc_sat_f64_s` handles NaN
@@ -90,6 +92,10 @@ export const toI32 = n => {
     const inner = n[1]
     return Array.isArray(inner) ? typed(inner, 'i32') : inner
   }
+  if (Array.isArray(n) && n[0] === 'f64.const' && typeof n[1] === 'number') {
+    const v = n[1]
+    return typed(['i32.const', Number.isFinite(v) ? v | 0 : 0], 'i32')
+  }
   // Leaf nodes are cheap to duplicate; for everything else, evaluate once via local.tee.
   const isLeaf = Array.isArray(n) && n.length <= 2 &&
     (n[0] === 'f64.const' || n[0] === 'local.get' || n[0] === 'global.get')
@@ -117,11 +123,14 @@ export const fromI64 = n => typed(['f64.reinterpret_i64', n], 'f64')
 
 // === Nullish sentinels ===
 
-/** Null/undefined: one nullish value inside jz. NaN-boxed ATOM (type=0, aux=1, offset=0).
+/** Reserved atoms (PTR.ATOM tag, offset=0).
+ *    aux=1 → null      (NULL_NAN)
+ *    aux=2 → undefined (UNDEF_NAN)
+ *  See module/symbol.js for the broader reserved-atom-id scheme.
  *  Distinct from 0, NaN, and all pointers. Triggers default params.
  *  At the JS boundary, null and undefined preserve their identity for interop. */
-export const NULL_NAN = '0x7FF8000100000000'
-export const UNDEF_NAN = '0x7FF8000000000001'
+export const NULL_NAN = '0x' + (LAYOUT.NAN_PREFIX_BITS | (1n << BigInt(LAYOUT.AUX_SHIFT))).toString(16).toUpperCase().padStart(16, '0')
+export const UNDEF_NAN = '0x' + (LAYOUT.NAN_PREFIX_BITS | (2n << BigInt(LAYOUT.AUX_SHIFT))).toString(16).toUpperCase().padStart(16, '0')
 /** WAT-template-ready sentinel expressions for use in stdlib template strings.
  *  `f64.const nan:0xHEX` is 3 bytes shorter than `f64.reinterpret_i64 (i64.const ...)`. */
 export const NULL_WAT = `(f64.const nan:${NULL_NAN})`
@@ -148,15 +157,14 @@ export const BOXED_MUTATORS = new Set(['push', 'pop', 'shift', 'unshift', 'splic
 
 // === Pointer construction ===
 
-const NAN_PREFIX_BITS = 0x7FF8n
 const litI32 = n => Array.isArray(n) && n[0] === 'i32.const' && typeof n[1] === 'number' ? n[1] : null
 
 /** Pack (type, aux, offset) into the f64 NaN-box bit pattern as a hex string. */
 function packPtrBits(type, aux, offset) {
-  const bits = (NAN_PREFIX_BITS << 48n)
-    | ((BigInt(type) & 0xFn) << 47n)
-    | ((BigInt(aux) & 0x7FFFn) << 32n)
-    | (BigInt(offset >>> 0) & 0xFFFFFFFFn)
+  const bits = LAYOUT.NAN_PREFIX_BITS
+    | ((BigInt(type) & BigInt(LAYOUT.TAG_MASK)) << BigInt(LAYOUT.TAG_SHIFT))
+    | ((BigInt(aux) & BigInt(LAYOUT.AUX_MASK)) << BigInt(LAYOUT.AUX_SHIFT))
+    | (BigInt(offset >>> 0) & BigInt(LAYOUT.OFFSET_MASK))
   return '0x' + bits.toString(16).toUpperCase().padStart(16, '0')
 }
 
@@ -184,14 +192,14 @@ export function ptrOffsetIR(valIR, valType) {
     return ['i32.wrap_i64', ['i64.reinterpret_f64', valIR]]
   }
   inc('__ptr_offset')
-  return ['call', '$__ptr_offset', valIR]
+  return ['call', '$__ptr_offset', ['i64.reinterpret_f64', valIR]]
 }
 
 /** Map VAL.* → PTR.* when unambiguous. STRING is ambiguous (heap vs SSO). ARRAY maps
  *  to PTR.ARRAY but callers that want to skip forwarding must check separately. */
 const VAL_TO_PTR = {
   array: PTR.ARRAY, object: PTR.OBJECT, set: PTR.SET, map: PTR.MAP,
-  closure: PTR.CLOSURE, typed: PTR.TYPED, buffer: PTR.BUFFER,
+  closure: PTR.CLOSURE, typed: PTR.TYPED, buffer: PTR.BUFFER, date: PTR.OBJECT,
 }
 export const valKindToPtr = (vt) => VAL_TO_PTR[vt]
 
@@ -247,7 +255,7 @@ export function appendStaticSlots(slots, headerBytes = 0) {
   if (!ctx.runtime.staticPtrSlots) ctx.runtime.staticPtrSlots = []
   for (let i = 0; i < slots.length; i++) {
     const bits = slots[i]
-    if (((bits >> 48n) & 0xFFF8n) === NAN_PREFIX_BITS) {
+    if (((bits >> 48n) & 0xFFF8n) === BigInt(LAYOUT.NAN_PREFIX)) {
       ctx.runtime.staticPtrSlots.push(off + i * 8)
     }
   }
@@ -272,11 +280,22 @@ const PURE_OPS = new Set(['i32.const', 'f64.const', 'local.get', 'global.get',
   'i32.eq', 'i32.ne', 'i32.lt_s', 'i32.gt_s', 'i32.le_s', 'i32.ge_s', 'i32.eqz'])
 export const isPureIR = n => Array.isArray(n) && PURE_OPS.has(n[0]) && n.slice(1).every(c => !Array.isArray(c) || isPureIR(c))
 
+/** Check if AST node is a literal string: ['str', 'value']. */
+export const isLiteralStr = idx => Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string'
+
+/** Resolve compile-time value type from AST node (literal → type, name → lookup). */
+export const resolveValType = (node, valTypeOf, lookupValType) =>
+  valTypeOf(node) ?? (typeof node === 'string' ? lookupValType(node) : null)
+
+/** Check if AST node is a string reference to a known function name. */
+export const isFuncRef = (node, funcNames) => typeof node === 'string' && funcNames.has(node)
+
 /** Check if (a, op, b) is a postfix pattern: [op, name] and [, 1] literal. */
 export const isPostfix = (a, op, b) => Array.isArray(a) && a[0] === op && Array.isArray(b) && b[0] == null && b[1] === 1
 
-/** Emit a numeric constant with correct i32/f64 typing. */
-export const emitNum = v => Number.isInteger(v) && v >= -2147483648 && v <= 2147483647
+/** Emit a numeric constant with correct i32/f64 typing.
+ *  `-0` is f64-only (i32 has no signed zero) — preserve the sign by emitting f64. */
+export const emitNum = v => Number.isInteger(v) && v >= -2147483648 && v <= 2147483647 && !Object.is(v, -0)
   ? typed(['i32.const', v], 'i32') : typed(['f64.const', v], 'f64')
 
 // === Temp locals ===
@@ -328,6 +347,12 @@ export function toNumF64(node, v) {
   if (v.type === 'i32' || isLit(v)) return asF64(v)
   const vt = keyValType(node)
   if (vt === VAL.NUMBER || vt === VAL.BIGINT) return asF64(v)
+  if (vt === VAL.DATE) {
+    const ptr = v.ptrKind === VAL.DATE
+      ? v
+      : ['i32.wrap_i64', ['i64.reinterpret_f64', asF64(v)]]
+    return typed(['f64.load', ptr], 'f64')
+  }
   // intCertain locals: every reachable def is integer-valued, so the binding
   // never carries a NaN-boxed pointer — skip the __to_num wrapper.
   if (typeof node === 'string' && repOf(node)?.intCertain === true) return asF64(v)
@@ -339,7 +364,7 @@ export function toNumF64(node, v) {
   }
   if (!ctx.core.stdlib['__to_num']) return asF64(v)
   inc('__to_num')
-  return typed(['call', '$__to_num', asF64(v)], 'f64')
+  return typed(['call', '$__to_num', asI64(v)], 'f64')
 }
 
 /** Convert already-emitted WASM node to i32 boolean. NaN is falsy (like JS).
@@ -361,7 +386,7 @@ export function truthyIR(e) {
     // all other NaN-boxed pointers (SSO strings, heap ptrs, etc.) are truthy.
     if (e[0] === 'f64.reinterpret_i64' && Array.isArray(e[1]) && e[1][0] === 'i64.const') {
       const bits = String(e[1][1])
-      const FALSY = new Set([UNDEF_NAN, NULL_NAN, '0x7FF8000000000000', '0x7FFA800000000000'])
+      const FALSY = new Set([UNDEF_NAN, NULL_NAN, '0x7FF8000000000000', '0x7FFA400000000000'])
       return typed(['i32.const', FALSY.has(bits) ? 0 : 1], 'i32')
     }
     // Fresh pointer constructors never produce nullish. Treat as always truthy.
@@ -375,13 +400,13 @@ export function truthyIR(e) {
       const name = e[1][0] === '$' ? e[1].slice(1) : e[1]
       const vt = lookupValType(name)
       if (vt === VAL.ARRAY || vt === VAL.OBJECT || vt === VAL.SET || vt === VAL.MAP ||
-          vt === VAL.CLOSURE || vt === VAL.TYPED || vt === VAL.BUFFER || vt === VAL.REGEX) {
+          vt === VAL.CLOSURE || vt === VAL.TYPED || vt === VAL.BUFFER || vt === VAL.REGEX || vt === VAL.DATE) {
         return typed(['i32.eqz', isNullish(e)], 'i32')
       }
     }
   }
   inc('__is_truthy')
-  return typed(['call', '$__is_truthy', asF64(e)], 'i32')
+  return typed(['call', '$__is_truthy', asI64(e)], 'i32')
 }
 export const toBoolFromEmitted = truthyIR
 
@@ -400,9 +425,13 @@ export function usesDynProps(vt) {
  *  `target` is the var name receiving the literal (or null when escaping). */
 export function needsDynShadow(target) {
   if (!ctx.module.modules.collection) return false
+  // Functions/CLOSURE always need dynamic props so cross-module property
+  // access (fn.parse, i32.parse aliases) sees the same value as schema slots.
+  const vt = typeof target === 'string' ? (ctx.func.repByLocal?.get(target)?.val || ctx.scope.globalValTypes?.get(target)) : null
+  if (vt === 'closure' || usesDynProps(vt)) return true
   const dyn = ctx.types?.dynKeyVars
-  if (target == null) return ctx.types?.anyDynKey ?? true
-  return dyn ? dyn.has(target) : true
+  if (target == null) return ctx.types?.anyDynKey ?? false
+  return dyn ? dyn.has(target) : false
 }
 
 // === Variable storage abstraction ===
@@ -531,7 +560,29 @@ export const isNullish = (f64expr) => {
   }
   // Non-trivial expr: fall back to the helper — keeps binary size stable & preserves eval once.
   inc('__is_nullish')
-  return typed(['call', '$__is_nullish', f64expr], 'i32')
+  return typed(['call', '$__is_nullish', ['i64.reinterpret_f64', f64expr]], 'i32')
+}
+
+/** Check if f64 expr is exactly `undefined` (UNDEF_NAN). Returns i32.
+ *  Used by default-param semantics — only `undefined` (or missing arg) triggers
+ *  the default; `null` should pass through. */
+export const isUndef = (f64expr) => {
+  if (f64expr.ptrKind != null) return typed(['i32.const', 0], 'i32')
+  if (Array.isArray(f64expr)) {
+    if (f64expr[0] === 'f64.const') {
+      const lit = String(f64expr[1])
+      if (lit.startsWith('nan:')) {
+        const bits = lit.slice(4)
+        return typed(['i32.const', bits === UNDEF_NAN ? 1 : 0], 'i32')
+      }
+      return typed(['i32.const', 0], 'i32')
+    }
+    if (f64expr[0] === 'f64.reinterpret_i64' && Array.isArray(f64expr[1]) && f64expr[1][0] === 'i64.const') {
+      const bits = String(f64expr[1][1])
+      return typed(['i32.const', bits === UNDEF_NAN ? 1 : 0], 'i32')
+    }
+  }
+  return typed(['i64.eq', ['i64.reinterpret_f64', f64expr], ['i64.const', UNDEF_NAN]], 'i32')
 }
 
 // === Array layout helpers ===
@@ -560,16 +611,21 @@ export function elemStore(ptr, i, val) {
  *
  *  Optional `lenLocal`: caller already has the array length in an i32 local
  *  (e.g. from sizing the output before the loop). Reuses it instead of
- *  re-loading from ptr-8. */
-export function arrayLoop(arrExpr, bodyFn, lenLocal) {
-  inc('__ptr_offset')
-  const arr = temp('aa'), ptr = tempI32('ap'), i = tempI32('ai'), item = temp('av')
+ *  re-loading from ptr-8.
+ *  Optional `ptrLocal`: caller already has the resolved ARRAY data pointer in
+ *  an i32 local. Reuses it instead of calling __ptr_offset again. */
+export function arrayLoop(arrExpr, bodyFn, lenLocal, ptrLocal) {
+  const arr = ptrLocal ? null : temp('aa'), ptr = ptrLocal ?? tempI32('ap'), i = tempI32('ai'), item = temp('av')
   const len = lenLocal ?? tempI32('al')
   const id = ctx.func.uniq++
-  const setup = [
-    ['local.set', `$${arr}`, asF64(arrExpr)],
-    ['local.set', `$${ptr}`, ['call', '$__ptr_offset', ['local.get', `$${arr}`]]],
-  ]
+  const setup = []
+  if (!ptrLocal) {
+    inc('__ptr_offset')
+    setup.push(
+      ['local.set', `$${arr}`, asF64(arrExpr)],
+      ['local.set', `$${ptr}`, ['call', '$__ptr_offset', ['i64.reinterpret_f64', ['local.get', `$${arr}`]]]],
+    )
+  }
   if (!lenLocal) setup.push(
     ['local.set', `$${len}`, ['i32.load', ['i32.sub', ['local.get', `$${ptr}`], ['i32.const', 8]]]])
   setup.push(

package/src/jzify.js

@@ -26,19 +26,134 @@ export default function jzify(ast) {
   swIdx = 0
   argsIdx = 0
   doIdx = 0
+  // Hoist module-level vars: any `var x` inside nested blocks bubbles up.
+  const names = new Set()
+  ast = hoistVars(ast, names)
+  if (names.size) ast = prependDecls(ast, names)
   return transformScope(ast)
 }
 
+/**
+ * Walk function/script body, replacing `var` declarations with assignments and
+ * collecting names. Does not cross function/arrow boundaries — nested functions
+ * get their own hoist pass when wrapArrowBody processes them.
+ *
+ *   ['var', 'x']                              → null (bare decl, no-op)
+ *   ['var', ['=', x, init]]                   → ['=', x, init]
+ *   ['var', ['=', x, 1], ['=', y, 2]]         → [',', ['=', x, 1], ['=', y, 2]]
+ *   ['var', 'x', 'y']                         → null
+ *   ['in', ['var', x], obj]                   → ['in', x, obj]   (for-in head)
+ */
+function hoistVars(node, names) {
+  if (node == null || !Array.isArray(node)) return node
+  const op = node[0]
+  // Nested function/arrow: hoist within its own scope, prepend let-decl, return new node.
+  if (op === 'function') {
+    const inner = new Set()
+    let body = hoistVars(node[3], inner)
+    if (inner.size) body = prependDecls(body, inner)
+    return ['function', node[1], node[2], body]
+  }
+  if (op === '=>') {
+    const inner = new Set()
+    let body = hoistVars(node[2], inner)
+    if (inner.size) body = prependDecls(body, inner)
+    return ['=>', node[1], body]
+  }
+  if (op === 'in' || op === 'of') {
+    let lhs = node[1]
+    if (Array.isArray(lhs) && lhs[0] === 'var' && typeof lhs[1] === 'string' && lhs.length === 2) {
+      names.add(lhs[1])
+      lhs = lhs[1]
+    } else {
+      lhs = hoistVars(lhs, names)
+    }
+    return [op, lhs, hoistVars(node[2], names)]
+  }
+  // For-head `;` is positional (init; cond; update), not a statement sequence.
+  // Recurse into each slot but never filter nulls — empty slots are valid.
+  if (op === 'for') {
+    const head = node[1]
+    let h2
+    if (Array.isArray(head) && head[0] === ';') {
+      h2 = [';']
+      for (let i = 1; i < head.length; i++) h2.push(hoistVars(head[i], names))
+    } else {
+      h2 = hoistVars(head, names)
+    }
+    return ['for', h2, hoistVars(node[2], names)]
+  }
+  if (op === 'var') {
+    const decls = []
+    for (let i = 1; i < node.length; i++) {
+      const d = node[i]
+      if (typeof d === 'string') { names.add(d); continue }
+      if (Array.isArray(d) && d[0] === '=' && typeof d[1] === 'string') {
+        names.add(d[1])
+        decls.push(['=', d[1], hoistVars(d[2], names)])
+      }
+    }
+    if (decls.length === 0) return null
+    if (decls.length === 1) return decls[0]
+    return [',', ...decls]
+  }
+  // Filter null returns from `;` sequences (bare-var no-ops). `{}` is left
+  // to recurse normally — it may be either a block or an object literal,
+  // and we don't want to clobber `['{}', null]` (empty object literal).
+  if (op === ';') {
+    const out = [op]
+    for (let i = 1; i < node.length; i++) {
+      const c = hoistVars(node[i], names)
+      if (c != null) out.push(c)
+    }
+    if (out.length === 1) return null
+    if (out.length === 2) return out[1]
+    return out
+  }
+  const out = new Array(node.length)
+  out[0] = op
+  for (let i = 1; i < node.length; i++) out[i] = hoistVars(node[i], names)
+  return out
+}
+
+function prependDecls(body, names) {
+  const decl = ['let', ...names]
+  if (Array.isArray(body) && body[0] === ';') return [';', decl, ...body.slice(1)]
+  if (Array.isArray(body) && body[0] === '{}') {
+    const inner = body[1]
+    if (Array.isArray(inner) && inner[0] === ';') return ['{}', [';', decl, ...inner.slice(1)]]
+    if (inner == null) return ['{}', decl]
+    return ['{}', [';', decl, inner]]
+  }
+  return body == null ? decl : [';', decl, body]
+}
+
+/** Convert a named function declaration to a hoisted const arrow */
+function hoistFnDecl(name, params, body) {
+  const [p2, b2] = lowerArguments(params, body)
+  const decl = ['const', ['=', name, ['=>', p2, wrapArrowBody(b2)]]]
+  decl._hoisted = true
+  return decl
+}
+
 /** Transform a scope (module top-level or block body). Collects hoisted functions. */
 function transformScope(node) {
   if (!Array.isArray(node)) return transform(node)
 
   const [op, ...args] = node
 
+  // Single named function-statement at scope position: hoist as const arrow
+  if (op === 'function' && args[0]) return hoistFnDecl(...args)
+
   // Statement sequence: collect hoisted functions
   if (op === ';') {
     const hoisted = [], rest = []
     for (const stmt of args) {
+      // Statement-form named function declaration: hoist directly (skip expression handler)
+      if (Array.isArray(stmt) && stmt[0] === 'function' && stmt[1]) {
+        hoisted.push(hoistFnDecl(stmt[1], stmt[2], stmt[3]))
+        continue
+      }
       const t = transform(stmt)
       if (t == null) continue
       // Hoist function declarations to top of scope
@@ -152,27 +267,30 @@ const handlers = {
     }
   },
 
-  // function → arrow (named → hoisted const)
+  // function → arrow. Named function expression desugars to IIFE so the name is
+  // bound inside body per ES spec: `function f(){...f...}` → `(()=>{let f;f=arrow;return f})()`.
+  // Statement-form named functions are hoisted by transformScope before reaching here.
   'function'(name, params, body) {
     const [p2, b2] = lowerArguments(params, body)
     const arrow = ['=>', p2, wrapArrowBody(b2)]
-    if (name) { const decl = ['const', ['=', name, arrow]]; decl._hoisted = true; return decl }
+    if (name) {
+      return ['()', ['()', ['=>', null, ['{}', [';',
+        ['let', name],
+        ['=', name, arrow],
+        ['return', name]
+      ]]]], null]
+    }
     return arrow
   },
 
+  // `var` is hoisted away before transform reaches here. If one slips through
+  // (e.g. raw subscript output without going via jzify entry/wrapArrowBody),
+  // fall back to treating it as `let`.
   'var'(...args) {
-    // for-in/for-of: ['var', ['in', 'k', obj]] → ['in', ['let', 'k'], obj]
-    if (args.length === 1 && Array.isArray(args[0]) && (args[0][0] === 'in' || args[0][0] === 'of')) {
-      const [, name, src] = args[0]
-      return [args[0][0], ['let', typeof name === 'string' ? name : transform(name)], transform(src)]
-    }
     return ['let', ...args.map(transform)]
   },
 
   '='(lhs, rhs) {
-    // var assignment: ['=', ['var', name], init] → let
-    if (Array.isArray(lhs) && lhs[0] === 'var')
-      return ['let', ['=', lhs[1], transform(rhs)]]
     // Chained property assignment: a.x = a.y = v → a.y = v; a.x = v
     if (Array.isArray(lhs) && lhs[0] === '.' && Array.isArray(rhs) && rhs[0] === '=') {
       const targets = []
@@ -237,10 +355,16 @@ const handlers = {
   // Block body: recurse as scope for hoisting
   '{}'(...args) { return ['{}', ...args.map(a => transformScope(a) ?? a)] },
 
-  // Export: recurse into exported declaration
+  // Export: recurse into exported declaration. Statement-form `export function name`
+  // and `export default function name` must be hoisted as const-arrows — otherwise
+  // the generic `function` handler wraps them in a named-IIFE (correct for *expressions*,
+  // wrong for declarations), producing `export ['()', IIFE]` which has no exportable binding.
   'export'(inner) {
+    if (Array.isArray(inner) && inner[0] === 'function' && inner[1]) {
+      return ['export', hoistFnDecl(inner[1], inner[2], inner[3])]
+    }
     if (Array.isArray(inner) && inner[0] === 'default' && Array.isArray(inner[1]) && inner[1][0] === 'function' && inner[1][1]) {
-      const decl = transform(inner[1])
+      const decl = hoistFnDecl(inner[1][1], inner[1][2], inner[1][3])
       return [';', decl, ['export', ['default', inner[1][1]]]]
     }
     return ['export', transform(inner)]
@@ -311,8 +435,26 @@ export function codegen(node, depth = 0) {
   // Statements
   if (op === ';') return a.map(s => codegen(s, depth)).filter(Boolean).join(';\n' + ind) + ';'
   if (op === '{}') {
-    const body = a.map(s => codegen(s, depth + 1)).filter(Boolean).join(';\n' + ind1)
-    return '{\n' + ind1 + body + (body ? ';' : '') + '\n' + ind + '}'
+    // Discriminate object literal / destructuring pattern from block.
+    // Object: `:` key-value, `,` of object-pattern items (id / `:` / `...` / `= default`),
+    //         lone string shorthand. Empty `{}` outputs the same string either way.
+    const body = a[0]
+    const isObjItem = (n) => typeof n === 'string' ||
+      (Array.isArray(n) && (n[0] === ':' || n[0] === '...' || n[0] === 'as' ||
+        (n[0] === '=' && typeof n[1] === 'string')))
+    const isObj = body == null ? false
+      : typeof body === 'string' ? true
+      : Array.isArray(body) && (body[0] === ':' || body[0] === '...' || body[0] === 'as' ||
+          (body[0] === ',' && body.slice(1).every(isObjItem)))
+    if (isObj) {
+      if (typeof body === 'string') return '{ ' + body + ' }'
+      if (body[0] === ',') return '{ ' + body.slice(1).map(x => codegen(x)).join(', ') + ' }'
+      return '{ ' + codegen(body) + ' }'
+    }
+    // Block: body is null, a single statement, or [';', ...stmts]
+    const stmts = body == null ? [] : (Array.isArray(body) && body[0] === ';' ? body.slice(1) : [body])
+    const rendered = stmts.map(s => codegen(s, depth + 1)).filter(Boolean).join(';\n' + ind1)
+    return '{\n' + ind1 + rendered + (rendered ? ';' : '') + '\n' + ind + '}'
   }
 
   // Declarations
@@ -329,16 +471,20 @@ export function codegen(node, depth = 0) {
   }
   if (op === 'while') return 'while (' + codegen(a[0]) + ') ' + wrapBlock(a[1], depth)
   if (op === 'for') {
-    if (a.length === 2) { // for...of / for...in
+    if (a.length === 2) { // ['for', head, body] — subscript shape
       const [head, body] = a
       if (Array.isArray(head) && (head[0] === 'of' || head[0] === 'in'))
-        return 'for (' + codegen(head[1]) + ' ' + head[0] + ' ' + codegen(head[2]) + ') ' + codegen(body, depth)
+        return 'for (' + codegen(head[1]) + ' ' + head[0] + ' ' + codegen(head[2]) + ') ' + wrapBlock(body, depth)
       // ['let'/'const', ['in'/'of', name, obj]] — subscript wraps var→let around in/of
       if (Array.isArray(head) && (head[0] === 'let' || head[0] === 'const') && Array.isArray(head[1]) && (head[1][0] === 'in' || head[1][0] === 'of'))
-        return 'for (' + head[0] + ' ' + codegen(head[1][1]) + ' ' + head[1][0] + ' ' + codegen(head[1][2]) + ') ' + codegen(body, depth)
-      return 'for (' + codegen(head) + ') ' + codegen(body, depth)
+        return 'for (' + head[0] + ' ' + codegen(head[1][1]) + ' ' + head[1][0] + ' ' + codegen(head[1][2]) + ') ' + wrapBlock(body, depth)
+      // C-style head [';', init, cond, update] is positional — empty slots are valid,
+      // must not flow through the generic `;` joiner (which adds newlines + a trailing `;`).
+      if (Array.isArray(head) && head[0] === ';')
+        return 'for (' + (head[1] == null ? '' : codegen(head[1])) + '; ' + (head[2] == null ? '' : codegen(head[2])) + '; ' + (head[3] == null ? '' : codegen(head[3])) + ') ' + wrapBlock(body, depth)
+      return 'for (' + codegen(head) + ') ' + wrapBlock(body, depth)
     }
-    return 'for (' + (codegen(a[0]) || '') + '; ' + (codegen(a[1]) || '') + '; ' + (codegen(a[2]) || '') + ') ' + codegen(a[3], depth)
+    return 'for (' + (codegen(a[0]) || '') + '; ' + (codegen(a[1]) || '') + '; ' + (codegen(a[2]) || '') + ') ' + wrapBlock(a[3], depth)
   }
   if (op === 'return') return 'return ' + codegen(a[0])
   if (op === 'throw') return 'throw ' + codegen(a[0])
@@ -372,10 +518,20 @@ export function codegen(node, depth = 0) {
   // Property access
   if (op === '.') return codegen(a[0]) + '.' + a[1]
   if (op === '?.') return codegen(a[0]) + '?.' + a[1]
-  if (op === '[]') return codegen(a[0]) + '[' + codegen(a[1]) + ']'
-
-  // Array/object literals
-  if (op === '[') return '[' + a.map(x => codegen(x)).join(', ') + ']'
+  if (op === '?.[]') return codegen(a[0]) + '?.[' + codegen(a[1]) + ']'
+  if (op === '?.()') return codegen(a[0]) + '?.(' + a.slice(1).map(x => codegen(x)).join(', ') + ')'
+  if (op === '[]') {
+    // Array literal: ['[]', body] (length 2 → a.length 1). body may be null (empty),
+    // a single element, or a [',', ...items] sequence.
+    if (a.length === 1) {
+      if (a[0] == null) return '[]'
+      const body = a[0]
+      if (Array.isArray(body) && body[0] === ',') return '[' + body.slice(1).map(x => codegen(x)).join(', ') + ']'
+      return '[' + codegen(body) + ']'
+    }
+    // Subscript: ['[]', obj, idx]
+    return codegen(a[0]) + '[' + codegen(a[1]) + ']'
+  }
   if (op === ':') return codegen(a[0]) + ': ' + codegen(a[1])
   if (op === 'str') return JSON.stringify(a[0])
   if (op === '//') return '/' + a[0] + '/' + (a[1] || '')
@@ -391,9 +547,10 @@ export function codegen(node, depth = 0) {
   // Spread
   if (op === '...') return '...' + codegen(a[0])
 
-  // Import
+  // Import / export rename
   if (op === 'import') return 'import ' + codegen(a[0])
   if (op === 'from') return codegen(a[0]) + ' from ' + codegen(a[1])
+  if (op === 'as') return codegen(a[0]) + ' as ' + codegen(a[1])
 
   // Unary prefix
   if (a.length === 1) {

package/src/narrow.js

@@ -8,6 +8,7 @@
  */
 
 import { ctx } from './ctx.js'
+import { isLiteralStr } from './ir.js'
 import {
   VAL,
   analyzeBody, analyzeLocals,
@@ -307,14 +308,41 @@ export default function narrowSignatures(programFacts, ast) {
   }
 
   const poison = field => r => { r[field] = null }
+  // Default-aware val inference. Adds two fallbacks beyond inferArgType's
+  // body-local `callerValTypes` lookup so a hot recursive helper like
+  // `uleb(n, buffer = []) { ... return uleb(n, buffer) }` resolves the
+  // recursive `buffer` arg to VAL.ARRAY (via callerParamFacts on iter 2,
+  // or via the caller's own default expression on iter 1).
+  const inferValAtSite = (arg, state) => {
+    const v = inferArgType(arg, state.callerValTypes)
+    if (v != null) return v
+    if (typeof arg !== 'string') return null
+    const fromParam = state.callerParamFacts('val')?.get(arg)
+    if (fromParam != null) return fromParam
+    const def = state.callerFunc?.defaults?.[arg]
+    return def != null ? valTypeOf(def) || null : null
+  }
+  // Substitute the default expression for a missing positional arg, so
+  // `uleb(n)` doesn't poison buffer.val despite `buffer = []` provably
+  // yielding VAL.ARRAY at runtime — unblocks inline ARRAY len/push fast
+  // paths in encode.js's hot uleb/i32/i64 helpers.
+  const defaultArg = (state, k) => {
+    const pname = state.func.sig.params[k]?.name
+    return pname != null ? state.func.defaults?.[pname] : null
+  }
   const mergeRule = (field, infer) => ({
-    missing: poison(field),
+    missing(r, k, state) {
+      if (r[field] === null) return
+      const def = defaultArg(state, k)
+      if (def != null) mergeParamFact(r, field, infer(def, k, state))
+      else r[field] = null
+    },
     apply(r, arg, k, state) {
       if (r[field] !== null) mergeParamFact(r, field, infer(arg, k, state))
     },
   })
   const runFixpoint = () => runCallsiteLattice([
-    mergeRule('val', (arg, _k, state) => inferArgType(arg, state.callerValTypes)),
+    mergeRule('val', (arg, _k, state) => inferValAtSite(arg, state)),
     {
       missing: poison('wasm'),
       apply(r, arg, _k, state) {
@@ -856,7 +884,6 @@ const TYPED_ARRAY_CTOR = /^(Float|Int|Uint|BigInt|BigUint)(8|16|32|64)(Clamped)?
 export function refineDynKeys(programFacts) {
   if (!ctx.types.anyDynKey) return
   const { paramReps, valueUsed } = programFacts
-  const isLitStr = idx => Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string'
 
   // Per-function type map: param vtypes from paramReps, plus locals
   // we can prove are typed arrays from `let v = new TypedArray(...)`. After
@@ -882,6 +909,7 @@ export function refineDynKeys(programFacts) {
           if (Array.isArray(init) && init[0] === '()' && typeof init[1] === 'string' && init[1].startsWith('new.'))
             ctor = init[1].slice(4)
           if (ctor && TYPED_ARRAY_CTOR.test(ctor)) map.set(d[1], VAL.TYPED)
+          else if (Array.isArray(init) && init[0] === '[') map.set(d[1], VAL.ARRAY)
           else if (typeof init === 'string' && map.has(init)) map.set(d[1], map.get(init))
         }
       }
@@ -898,7 +926,7 @@ export function refineDynKeys(programFacts) {
     const op = node[0]
     if (op === '[]') {
       const idx = node[2]
-      if (!isLitStr(idx)) {
+      if (!isLiteralStr(idx)) {
         const obj = node[1]
         const vt = typeof obj === 'string' ? typeMap.get(obj) : null
         if (!NON_DYN_VTS.has(vt)) real = true