jz 0.3.0 → 0.4.0

package/README.md

@@ -22,7 +22,7 @@ JZ distills the modern functional core – the "good parts" ([Crockford](https:/
 
 * **Static AOT** – no runtime, no GC, no dynamic constructs.
 * **Valid jz = valid js** — test in browser, compile to wasm.
-* **Minimal** — output is close to hand-written WAT.
+* **Minimal** — output is close to hand-written WAT; CI gates it to stay at least as small and fast as AssemblyScript and Porffor on the bench corpus ([CONTRIBUTING](CONTRIBUTING.md#performance--size-invariant)).
 <!-- * **Realtime** — compiles faster than `eval`, useful for live-coding and REPL. -->
 
 | Good for                    | Not for                    |
@@ -82,7 +82,15 @@ Options are passed as `jz(source, opts)` or `compile(source, opts)`. Common ones
 
 ```sh
 # Compile
-jz program.js # → program.wasm
+jz program.js              # → program.wasm
+jz program.js --wat        # → program.wat
+jz program.js -o out.wasm  # custom output (- for stdout)
+
+# Optimization level: -O0 off, -O1 size, -O2 balanced, -O3 speed
+jz program.js -O3
+
+# Runtime-service lowering: js (default) or wasi
+jz program.js --host wasi
 
 # Evaluate
 jz -e "1 + 2" # 3
@@ -91,6 +99,7 @@ jz -e "1 + 2" # 3
 jz --help
 ```
 
+
 ## Language
 
 JZ is a strict functional JS subset. Built-in `jzify` transform extends support to legacy patterns.
@@ -467,18 +476,19 @@ cc program.c -o program
 
 | | jz | [Node](https://nodejs.org/) | [Porffor](https://github.com/CanadaHonk/porffor) | [AS](https://github.com/AssemblyScript/assemblyscript) | WAT | C | [Go](https://go.dev/) | [Zig](https://ziglang.org/) | [Rust](https://www.rust-lang.org/) | [NumPy](https://numpy.org/) |
 |---|---|---|---|---|---|---|---|---|---|---|
-| [biquad](bench/biquad/biquad.js) | 4.63ms<br>4.0kB | 8.68ms<br>3.2kB | fails | 6.59ms<br>1.9kB | 6.45ms<br>767 B | 5.30ms | 8.91ms<br>fma | 5.06ms | 5.28ms | 3.12s |
-| [tokenizer](bench/tokenizer/tokenizer.js) | 0.07ms<br>1.8kB | 0.12ms<br>1.4kB | 0.34ms<br>2.6kB | 0.05ms<br>1.5kB | 0.08ms<br>344 B | 0.14ms | 0.07ms | 0.12ms | 0.12ms | 5.15ms |
-| [mat4](bench/mat4/mat4.js) | 2.12ms<br>3.7kB | 11.80ms<br>1.2kB | 88.54ms<br>2.4kB<br>diff | 9.21ms<br>1.6kB | 8.06ms<br>414 B | 2.73ms | 11.93ms | 2.73ms | 1.77ms | 387.60ms |
-| [aos](bench/aos/aos.js) | 1.11ms<br>2.3kB | 1.26ms<br>1.1kB | fails | 1.33ms<br>2.2kB | 1.07ms<br>481 B | 1.20ms | 0.91ms | 0.91ms | 1.20ms | 2.57ms |
-| [mandelbrot](bench/mandelbrot/mandelbrot.js) | 8.02ms<br>1.2kB | 9.06ms<br>1.8kB | 9.71ms<br>3.0kB | 8.00ms<br>1.3kB | — | 8.31ms | 8.80ms | 7.83ms | 8.52ms | — |
-| [bitwise](bench/bitwise/bitwise.js) | 0.98ms<br>1.3kB | 3.76ms<br>1005 B | fails | 8.79ms<br>1.5kB | 4.86ms<br>355 B | 1.30ms | 5.20ms | 4.15ms | 1.30ms | 14.72ms |
-| [poly](bench/poly/poly.js) | 0.27ms<br>1.4kB | 1.62ms<br>1014 B | fails | 0.73ms<br>1.3kB | 0.81ms<br>359 B | 0.57ms | 0.79ms | 0.89ms | 0.63ms | 0.60ms |
-| [callback](bench/callback/callback.js) | 0.03ms<br>1.6kB | 0.69ms<br>828 B | fails | 1.04ms<br>1.9kB | 0.24ms<br>267 B | 0.08ms | 0.23ms | 0.01ms | 0.12ms | 1.78ms |
-| [json](bench/json/json.js) | 0.25ms<br>10.9kB | 0.36ms<br>1.2kB | fails | — | — | 0.25ms | 1.16ms | 0.64ms | 0.65ms | 1.20ms |
-| [watr](bench/watr/watr.js) | 1.04ms<br>169.8kB | 1.05ms<br>2.6kB | fails | — | — | — | — | — | — | — |
-
-_Numbers from `node bench/bench.mjs` on Apple Silicon. Porffor cells were refreshed with `porf` 0.61.13; `fails` means the latest Porffor compiler/runtime did not complete that benchmark._
+| [biquad](bench/biquad/biquad.js) | 6.40ms<br>4.1kB | 12.02ms<br>3.2kB | fails | 8.88ms<br>1.9kB | 6.44ms<br>767 B | 5.30ms | 8.96ms<br>fma | 5.04ms | 5.27ms | 3.09s |
+| [tokenizer](bench/tokenizer/tokenizer.js) | 0.10ms<br>1.9kB | 0.20ms<br>2.0kB | 0.41ms<br>3.2kB | 0.08ms<br>1.6kB | 0.10ms<br>344 B | 0.13ms | 0.08ms | 0.14ms | 0.12ms | 5.13ms |
+| [mat4](bench/mat4/mat4.js) | 2.12ms<br>3.0kB | 11.90ms<br>1.2kB | 88.68ms<br>2.4kB<br>diff | 9.44ms<br>1.6kB | 8.10ms<br>414 B | 2.76ms | 12.51ms | 2.74ms | 1.78ms | 389.44ms |
+| [aos](bench/aos/aos.js) | 1.61ms<br>2.0kB | 1.82ms<br>1.1kB | fails | 1.91ms<br>2.2kB | 1.07ms<br>481 B | 1.20ms | 0.90ms | 0.90ms | 1.20ms | 2.55ms |
+| [mandelbrot](bench/mandelbrot/mandelbrot.js) | 12.24ms<br>1.2kB | 13.53ms<br>1.8kB | 13.47ms<br>3.0kB | 12.23ms<br>1.3kB | — | 12.26ms | 12.46ms | 12.31ms | 12.23ms | — |
+| [bitwise](bench/bitwise/bitwise.js) | 1.62ms<br>1.3kB | 5.25ms<br>1005 B | fails | 11.97ms<br>1.5kB | 4.95ms<br>355 B | 1.30ms | 5.23ms | 4.16ms | 1.30ms | 14.77ms |
+| [poly](bench/poly/poly.js) | 0.37ms<br>1.4kB | 2.29ms<br>1014 B | fails | 1.13ms<br>1.3kB | 0.81ms<br>359 B | 0.52ms | 0.80ms | 0.80ms | 0.57ms | 0.61ms |
+| [callback](bench/callback/callback.js) | 0.05ms<br>1.5kB | 0.86ms<br>828 B | fails | 1.48ms<br>1.9kB | 0.25ms<br>267 B | 0.10ms | 0.20ms | 0.01ms | 0.09ms | 1.81ms |
+| [json](bench/json/json.js) | 0.23ms<br>10.9kB | 0.37ms<br>1.2kB | fails | — | — | 0.21ms | 1.17ms | 0.69ms | 0.68ms | 1.20ms |
+| [sort](bench/sort/sort.js) | 8.44ms<br>1.9kB | 9.98ms<br>1.6kB | fails | 10.18ms<br>1.9kB | — | 8.85ms | 10.36ms | 8.84ms | 9.37ms | 5.05ms |
+| [crc32](bench/crc32/crc32.js) | 11.96ms<br>1.5kB | 13.35ms<br>1.8kB | 80.76ms<br>3.1kB | 12.04ms<br>1.4kB | — | 10.69ms | 9.30ms | 9.45ms | 9.38ms | 0.24ms |
+
+_Numbers from `node bench/bench.mjs` on Apple Silicon._ `optimize: 'size'|'speed'|'balanced'` provides a size/speed tradeoff leverage.
 
 <details>
 <summary><strong>Optimizations</strong></summary>

package/cli.js

@@ -10,7 +10,8 @@ import { pathToFileURL } from 'url'
 import { execFileSync } from 'child_process'
 import { parse } from 'subscript/feature/jessie'
 import jz, { compile } from './index.js'
-import jzifyFn, { codegen } from './src/jzify.js'
+import jzifyFn from './src/jzify.js'
+import { codegen } from './src/codegen.js'
 import { createRequire } from 'module'
 
 const jzRequire = createRequire(import.meta.url)
@@ -32,13 +33,21 @@ Examples:
   jz program.js --wat              # → program.wat
   jz program.js -o out.wasm        # custom output name
   jz program.js -o -               # write to stdout
+  jz program.js -O3                # aggressive optimization
+  jz program.js -Os                # optimize for size
+  jz program.js --host wasi        # emit WASI Preview 1 imports
   jz --strict program.js           # strict mode
   jz --jzify lib.js                # → lib.jz
   jz -e "1 + 2"
 
 Options:
   --output, -o <file>       Output file (.wat, .wasm, or - for stdout)
-  --strict                  Strict jz mode (no auto-transform)
+  -O<n>, --optimize <n>     Optimization level: 0 off, 1 size-only, 2 default,
+                            3 aggressive. Aliases: -Os/size, -Ob/balanced, -Of/speed.
+  --host <js|wasi>          Runtime-service lowering (default js)
+  --no-alloc                Omit _alloc/_clear allocator exports (standalone wasm)
+  --names                   Emit wasm name section for profilers/debuggers
+  --strict                  Strict jz mode (no auto-transform), reject dynamic fallbacks
   --jzify                   Transform JS to jz (no compilation)
   --eval, -e                Evaluate expression or file
   --wat                     Output WAT text instead of binary
@@ -109,16 +118,31 @@ async function handleJzify(args) {
   }
 }
 
+// -O<n>/-Os/-Ob/-Of and --optimize <val> → value accepted by compile()'s `optimize` opt
+const OPT_ALIAS = { s: 'size', b: 'balanced', f: 'speed' }
+function parseOptimize(v) {
+  if (v == null) return undefined
+  if (/^\d+$/.test(v)) return +v
+  return OPT_ALIAS[v] ?? v
+}
+
 async function handleCompile(args) {
   let inputFile = null, outputFile = null, wat = false, strict = false, resolveNode = false, importsFile = null
+  let optimize, host, alloc = true, names = false
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--output' || args[i] === '-o') outputFile = args[++i]
-    else if (args[i] === '--wat') wat = true
-    else if (args[i] === '--strict') strict = true
-    else if (args[i] === '--resolve') resolveNode = true
-    else if (args[i] === '--imports') importsFile = args[++i]
-    else if (!inputFile) inputFile = args[i]
+    const a = args[i]
+    if (a === '--output' || a === '-o') outputFile = args[++i]
+    else if (a === '--wat') wat = true
+    else if (a === '--strict') strict = true
+    else if (a === '--resolve') resolveNode = true
+    else if (a === '--imports') importsFile = args[++i]
+    else if (a === '--optimize' || a === '-O') optimize = parseOptimize(args[++i])
+    else if (/^-O.+/.test(a)) optimize = parseOptimize(a.slice(2))
+    else if (a === '--host') host = args[++i]
+    else if (a === '--no-alloc') alloc = false
+    else if (a === '--names') names = true
+    else if (!inputFile) inputFile = a
   }
 
   if (!inputFile) throw new Error('No input file specified')
@@ -178,7 +202,12 @@ async function handleCompile(args) {
   const opts = {
     wat,
     jzify: !strict && !inputFile.endsWith('.jz'),
+    strict,
     importMetaUrl: pathToFileURL(resolve(inputFile)).href,
+    ...(optimize !== undefined && { optimize }),
+    ...(host && { host }),
+    ...(alloc === false && { alloc: false }),
+    ...(names && { profileNames: true }),
     ...(Object.keys(modules).length && { modules }),
   }
 

package/index.js

@@ -51,18 +51,11 @@ import {
   memory as enhanceMemory, instantiate as instantiateRuntime,
 } from './src/host.js'
 
-const importSpecMayReturnExternal = (spec) => {
-  if (typeof spec === 'function') return true
-  return false
-}
-
-const importsMayReturnExternal = (imports) => {
-  if (!imports) return false
-  for (const mod of Object.values(imports))
-    for (const spec of Object.values(mod || {}))
-      if (importSpecMayReturnExternal(spec)) return true
-  return false
-}
+// A host import that's a JS function may hand back any value, including a host
+// object — which arrives in wasm as a PTR.EXTERNAL ref. Constants/typed specs can't.
+const importsMayReturnExternal = (imports) =>
+  !!imports && Object.values(imports).some(mod =>
+    Object.values(mod || {}).some(spec => typeof spec === 'function'))
 
 const nowMs = () => globalThis.performance?.now ? globalThis.performance.now() : Date.now()
 
@@ -227,8 +220,13 @@ jz.compile = (code, opts = {}) => {
   const ast = time('prepare', () => prepare(parsed))
 
   // Auto-detect optimization tuning from source characteristics when the user
-  // hasn't provided any optimize option.
-  if (opts.optimize == null) {
+  // hasn't provided any optimize option. At the default level its only *live*
+  // output is the typed-array scalarization thresholds (every other override —
+  // watr off, sortStrPool/hoistPtr on — already matches the level-2 preset), so
+  // skip the AST scan entirely unless the program touches typed arrays.
+  // NOTE: if the level-2 default ever flips watr on, drop this guard so the
+  // machine-generated-code heuristic in detectOptimizeConfig can take effect.
+  if (opts.optimize == null && ctx.module.modules.typedarray) {
     const autoCfg = detectOptimizeConfig(ast, code)
     if (Object.keys(autoCfg).length) {
       ctx.transform.optimize = resolveOptimize(autoCfg)
@@ -253,7 +251,26 @@ jz.compile = (code, opts = {}) => {
   }
 
   const cfg = ctx.transform.optimize
-  const optimized = cfg.watr ? time('watrOptimize', () => watrOptimize(module)) : module
+  // watr's `loopify` collapses the `(block $brk (loop … (br_if $brk !cond) … (br $loop)))`
+  // idiom into `(loop … (if cond …))` — sound, but destroys the exact shape jz's
+  // post-watr vectorizer scans for. Disable loopify when vectorize is going to run.
+  //
+  // watr config:
+  //   true / 'full' → all default passes (includes `inlineOnce` / `inline` / `coalesce`)
+  //   'light'       → everything except inlining + coalesce. Default at level 2.
+  //                   `inlineOnce` reshapes codegen the way slot-type / LICM tests scan for,
+  //                   and miscompiles regex `split(/\s+/)`. `coalesceLocals` on its own (i.e.
+  //                   without the cleanup that follows inlining) breaks `/a.+b/.test("ab")`
+  //                   — likely a stale alias the post-inline propagate sweep normally tidies
+  //                   up at L3. Dropping both still keeps treeshake / dedupe / dedupTypes /
+  //                   propagate / packData / fold / peephole / vacuum / mergeBlocks / brif /
+  //                   loopify / offset / unbranch / identity / strength / globals etc.
+  //   false         → skip watr entirely (level 0/1).
+  let watrOpts
+  if (cfg.watr === 'light') watrOpts = { inline: false, inlineOnce: false, coalesce: false, loopify: !cfg.vectorizeLaneLocal }
+  else if (cfg.vectorizeLaneLocal) watrOpts = { loopify: false }
+  else watrOpts = true
+  const optimized = cfg.watr ? time('watrOptimize', () => watrOptimize(module, watrOpts)) : module
   // Final peephole pass: watrOptimize's inliner can re-introduce rebox/unbox at boundaries
   // (e.g. inlined closure body's `i32.wrap_i64 (i64.reinterpret_f64 __env)` next to caller's
   // `boxPtrIR(g)` rebox). Our fusedRewrite folds these, watr's peephole doesn't.

package/module/array.js

@@ -251,7 +251,13 @@ export default (ctx) => {
   ctx.core.emit['new.Array'] = (len) => {
     const n = tempI32('alen')
     const nIR = ['local.get', `$${n}`]
-    const out = allocPtr({ type: PTR.ARRAY, len: nIR, cap: nIR, tag: 'newarr' })
+    // L3/'speed' bumps the cap floor to skip the first growth cycles (default 0
+    // → grow on first push). Length stays exactly what the user requested.
+    const minCap = ctx.transform.optimize?.arrayMinCap | 0
+    const capIR = minCap > 0
+      ? ['select', ['i32.const', minCap], nIR, ['i32.gt_s', ['i32.const', minCap], nIR]]
+      : nIR
+    const out = allocPtr({ type: PTR.ARRAY, len: nIR, cap: capIR, tag: 'newarr' })
     return typed(['block', ['result', 'f64'],
       ['local.set', `$${n}`, len == null ? ['i32.const', 0] : asI32(emit(len))],
       out.init,
@@ -378,7 +384,7 @@ export default (ctx) => {
   ctx.core.stdlib['__arr_from'] = `(func $__arr_from (param $src i64) (result f64)
     (local $len i32) (local $dst i32)
     (local.set $len (call $__len (local.get $src)))
-    (local.set $dst (call $__alloc_hdr (local.get $len) (local.get $len) (i32.const 8)))
+    (local.set $dst (call $__alloc_hdr (local.get $len) (local.get $len)))
     (memory.copy (local.get $dst) (call $__ptr_offset (local.get $src)) (i32.shl (local.get $len) (i32.const 3)))
     (call $__mkptr (i32.const ${PTR.ARRAY}) (i32.const 0) (local.get $dst)))`
 
@@ -434,7 +440,7 @@ export default (ctx) => {
         (i32.lt_u (local.get $off) (i32.const 8)))
       (then
         (local.set $newCap (select (local.get $minCap) (i32.const 4) (i32.gt_s (local.get $minCap) (i32.const 4))))
-        (local.set $newOff (call $__alloc_hdr (i32.const 0) (local.get $newCap) (i32.const 8)))
+        (local.set $newOff (call $__alloc_hdr (i32.const 0) (local.get $newCap)))
         (return (call $__mkptr (i32.const ${PTR.ARRAY}) (i32.const 0) (local.get $newOff)))))
     (local.set $oldCap (i32.load (i32.sub (local.get $off) (i32.const 4))))
     (if (i32.ge_s (local.get $oldCap) (local.get $minCap))
@@ -444,7 +450,7 @@ export default (ctx) => {
       (i32.shl (local.get $oldCap) (i32.const 1))
       (i32.gt_s (local.get $minCap) (i32.shl (local.get $oldCap) (i32.const 1)))))
     (local.set $len (i32.load (i32.sub (local.get $off) (i32.const 8))))
-    (local.set $newOff (call $__alloc_hdr (local.get $len) (local.get $newCap) (i32.const 8)))
+    (local.set $newOff (call $__alloc_hdr (local.get $len) (local.get $newCap)))
     (memory.copy (local.get $newOff) (local.get $off) (i32.shl (local.get $len) (i32.const 3)))
     ${headerPropsCopyIR()}
     ${maybeDynMoveIR()}
@@ -464,7 +470,7 @@ export default (ctx) => {
       (i32.shl (local.get $oldCap) (i32.const 1))
       (i32.gt_s (local.get $minCap) (i32.shl (local.get $oldCap) (i32.const 1)))))
     (local.set $len (i32.load (i32.sub (local.get $off) (i32.const 8))))
-    (local.set $newOff (call $__alloc_hdr (local.get $len) (local.get $newCap) (i32.const 8)))
+    (local.set $newOff (call $__alloc_hdr (local.get $len) (local.get $newCap)))
     (memory.copy (local.get $newOff) (local.get $off) (i32.shl (local.get $len) (i32.const 3)))
     ${headerPropsCopyIR()}
     ${maybeDynMoveIR()}
@@ -522,7 +528,9 @@ export default (ctx) => {
         const slots = elems.map(e => extractF64Bits(asF64(emit(e))))
         if (slots.every(b => b !== null)) return staticArrayPtr(slots)
       }
-      const a = allocArray(len, Math.max(len, 4))  // min cap=4 for small pushes
+      // L3/'speed' bumps the cap floor (default 4) to skip more growth cycles.
+      const minCap = Math.max(ctx.transform.optimize?.arrayMinCap | 0, 4)
+      const a = allocArray(len, Math.max(len, minCap))
       const body = [...a.setup]
       for (let i = 0; i < len; i++)
         body.push(['f64.store', slotAddr(a.local, i), asF64(emit(elems[i]))])
@@ -530,7 +538,8 @@ export default (ctx) => {
       return typed(['block', ['result', 'f64'], ...body], 'f64')
     }
 
-    const a = allocArray(0, Math.max(elems.length, 4))
+    const minCap = Math.max(ctx.transform.optimize?.arrayMinCap | 0, 4)
+    const a = allocArray(0, Math.max(elems.length, minCap))
     const out = temp('sa'), pos = tempI32('sp')
     inc('__arr_set_idx_ptr')
 

package/module/collection.js

@@ -11,6 +11,7 @@
 import { typed, asF64, asI64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64, allocPtr, undefExpr } from '../src/ir.js'
 import { emit, emitFlat } from '../src/emit.js'
 import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
+import { hasOwnContinue } from '../src/ast.js'
 import { inc, PTR, LAYOUT } from '../src/ctx.js'
 
 const SET_ENTRY = 16  // hash + key
@@ -186,7 +187,7 @@ function genUpsertGrow(name, entrySize, hashFn, eqExpr, typeConst, strict = fals
     (if (i32.ge_s (i32.mul (local.get $size) (i32.const 4)) (i32.mul (local.get $cap) (i32.const 3)))
       (then
         (local.set $newcap (i32.shl (local.get $cap) (i32.const 1)))
-        (local.set $newptr (call $__alloc_hdr (i32.const 0) (local.get $newcap) (i32.const ${entrySize})))
+        (local.set $newptr (call $__alloc_hdr_n (i32.const 0) (local.get $newcap) (i32.const ${entrySize})))
         (local.set $i (i32.const 0))
         (block $rd (loop $rl
           (br_if $rd (i32.ge_s (local.get $i) (local.get $cap)))
@@ -335,14 +336,14 @@ export default (ctx) => {
     __hash_has: () => ctx.features.external
       ? ['__str_hash', '__str_eq', '__ptr_type', '__ext_has']
       : ['__str_hash', '__str_eq', '__ptr_type'],
-    __hash_new: ['__alloc_hdr'],
-    __hash_new_small: ['__alloc_hdr', '__mkptr'],
+    __hash_new: ['__alloc_hdr_n'],
+    __hash_new_small: ['__alloc_hdr_n', '__mkptr'],
     __hash_get_local: ['__str_hash', '__str_eq'],
     __hash_get_local_h: ['__str_eq'],
     __hash_set_local_h: ['__str_eq'],
-    __hash_set_local: ['__str_hash', '__str_eq'],
+    __hash_set_local: ['__str_hash', '__str_eq', '__alloc_hdr_n', '__mkptr'],
     __ihash_get_local: ['__map_hash'],
-    __ihash_set_local: ['__map_hash', '__alloc_hdr', '__mkptr'],
+    __ihash_set_local: ['__map_hash', '__alloc_hdr_n', '__mkptr'],
     __dyn_get_t: ['__dyn_get_t_h', '__str_hash'],
     __dyn_get_t_h: ['__ihash_get_local', '__str_eq', '__is_nullish'],
     __dyn_get: ['__dyn_get_t', '__ptr_type'],
@@ -437,7 +438,7 @@ export default (ctx) => {
   // __map_new() → f64 — allocate empty Map (for JSON.parse, runtime creation)
   ctx.core.stdlib['__map_new'] = `(func $__map_new (result f64)
     (call $__mkptr (i32.const ${PTR.MAP}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
 
   // === Set ===
 
@@ -567,14 +568,17 @@ export default (ctx) => {
 
   ctx.core.stdlib['__hash_new'] = `(func $__hash_new (result f64)
     (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${INIT_CAP}) (i32.const ${MAP_ENTRY}))))`
 
   // Small initial capacity for propsPtr-style hashes (per-object dyn props).
   // Most receivers in real code carry 0-2 dyn props; paying 8-slot up-front
   // is wasted memory + probe-loop cache pressure. Grows to 4/8/... on demand.
+  // L3/'speed' opts into a larger initial cap (default 8) to skip 2→4→8 growth
+  // when AST-style nodes carry 3-5 props (watr.compile's profile).
+  const smallCap = Math.max(ctx.transform.optimize?.hashSmallInitCap | 0, 2)
   ctx.core.stdlib['__hash_new_small'] = `(func $__hash_new_small (result f64)
     (call $__mkptr (i32.const ${PTR.HASH}) (i32.const 0)
-      (call $__alloc_hdr (i32.const 0) (i32.const 2) (i32.const ${MAP_ENTRY}))))`
+      (call $__alloc_hdr_n (i32.const 0) (i32.const ${smallCap}) (i32.const ${MAP_ENTRY}))))`
 
   ctx.core.stdlib['__hash_get_local'] = genLookupStrict('__hash_get_local', MAP_ENTRY, '$__str_hash', strEq, PTR.HASH)
   ctx.core.stdlib['__hash_get_local_h'] = genLookupStrictPrehashed('__hash_get_local_h', MAP_ENTRY, strEq, PTR.HASH)
@@ -709,6 +713,11 @@ export default (ctx) => {
             (br_if $haveProps (i32.eq
               (i32.wrap_i64 (i64.and (i64.shr_u (local.get $props) (i64.const ${LAYOUT.TAG_SHIFT})) (i64.const ${LAYOUT.TAG_MASK})))
               (i32.const ${PTR.HASH})))
+            ;; Fresh array (header propsPtr=0, no shift, no props): skip the
+            ;; global hash probe — there's nothing to find. Shifted arrays read
+            ;; forwarding bytes here (low32=newOff, high32=-1) → non-zero, so
+            ;; this br_if doesn't fire and they fall through to __dyn_props.
+            (br_if $dynDone (i64.eqz (local.get $props)))
             (local.set $props (i64.const 0))))
         ;; OBJECT: heap-allocated (off >= __heap_start) carries propsPtr at
         ;; off-16 from __alloc_hdr. The slot is either 0 (no dyn props yet) or
@@ -1032,8 +1041,14 @@ export default (ctx) => {
     const ptrI64 = tempI64('hp'), srcOff = tempI32('hso'), srcType = tempI32('hst')
     if (!ctx.func.locals.has(varName)) ctx.func.locals.set(varName, 'f64')
     const id = ctx.func.uniq++
+    const brk = `$brk${id}`, loop = `$loop${id}`, cont = `$cont${id}`
     const va = asF64(emit(src))
-    const bodyFlat = emitFlat(body)
+    const needsCont = hasOwnContinue(body)
+    ctx.func.stack.push({ brk, loop: needsCont ? cont : loop })
+    let bodyFlat
+    try { bodyFlat = emitFlat(body) }
+    finally { ctx.func.stack.pop() }
+    const bodyBlock = needsCont ? [['block', cont, ...bodyFlat]] : bodyFlat
     inc('__ptr_type')
     return [
       // Save source ptr as i64
@@ -1054,16 +1069,16 @@ export default (ctx) => {
           ['local.set', `$${off}`, ['call', '$__ptr_offset', ['local.get', `$${ptrI64}`]]],
           ['local.set', `$${cap}`, ['call', '$__cap', ['local.get', `$${ptrI64}`]]],
           ['local.set', `$${i}`, ['i32.const', 0]],
-          ['block', `$brk${id}`, ['loop', `$loop${id}`,
-            ['br_if', `$brk${id}`, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
+          ['block', brk, ['loop', loop,
+            ['br_if', brk, ['i32.ge_s', ['local.get', `$${i}`], ['local.get', `$${cap}`]]],
             ['local.set', `$${slot}`, ['i32.add', ['local.get', `$${off}`],
               ['i32.mul', ['local.get', `$${i}`], ['i32.const', MAP_ENTRY]]]],
             ['if', ['i64.ne', ['i64.load', ['local.get', `$${slot}`]], ['i64.const', 0]],
               ['then',
                 ['local.set', `$${varName}`, ['f64.reinterpret_i64', ['i64.load', ['i32.add', ['local.get', `$${slot}`], ['i32.const', 8]]]]],
-                ...bodyFlat]],
+                ...bodyBlock]],
             ['local.set', `$${i}`, ['i32.add', ['local.get', `$${i}`], ['i32.const', 1]]],
-            ['br', `$loop${id}`]]]]]
+            ['br', loop]]]]]
     ]
   }
 }

package/module/core.js

@@ -42,6 +42,7 @@ export default (ctx) => {
     __length: ['__ptr_type', '__ptr_offset', '__str_len', '__len'],
     __typeof: ['__ptr_type', '__is_nullish'],
     __alloc_hdr: ['__alloc'],
+    __alloc_hdr_n: ['__alloc'],
   })
 
   ctx.core.stdlib['__is_nullish'] = `(func $__is_nullish (param $v i64) (result i32)
@@ -334,7 +335,21 @@ export default (ctx) => {
   // (NaN-boxed PTR.HASH) for ARRAY/HASH/MAP/SET; 0 means "no dyn props yet". This lets
   // __dyn_get_t / __dyn_set sidestep the global __dyn_props lookup on the hot path.
   // Read offsets relative to the returned data ptr stay unchanged (-8 len, -4 cap).
-  ctx.core.stdlib['__alloc_hdr'] = `(func $__alloc_hdr (param $len i32) (param $cap i32) (param $stride i32) (result i32)
+  // Default stride=8 (f64 NaN-boxed slot) — used by every Array/HASH/OBJECT alloc.
+  // Specialized over a generic (len, cap, stride) helper to drop a fat (i32.const 8)
+  // immediate at every call site (~20+) plus a param/local.get pair in the body.
+  // Non-8 strides (Set: 16, Map/HASH probe: 24, TypedArray raw: 1) use __alloc_hdr_n.
+  ctx.core.stdlib['__alloc_hdr'] = `(func $__alloc_hdr (param $len i32) (param $cap i32) (result i32)
+    (local $ptr i32)
+    (local.set $ptr (call $__alloc (i32.add (i32.const 16) (i32.shl (local.get $cap) (i32.const 3)))))
+    (i64.store (local.get $ptr) (i64.const 0))
+    (i32.store (i32.add (local.get $ptr) (i32.const 8)) (local.get $len))
+    (i32.store (i32.add (local.get $ptr) (i32.const 12)) (local.get $cap))
+    (i32.add (local.get $ptr) (i32.const 16)))`
+
+  // Generic header allocator for non-8 strides: Set (16), Map probe (24), TypedArray raw (1).
+  // Same 16-byte header layout as __alloc_hdr; per-entry stride is passed dynamically.
+  ctx.core.stdlib['__alloc_hdr_n'] = `(func $__alloc_hdr_n (param $len i32) (param $cap i32) (param $stride i32) (result i32)
     (local $ptr i32)
     (local.set $ptr (call $__alloc (i32.add (i32.const 16) (i32.mul (local.get $cap) (local.get $stride)))))
     (i64.store (local.get $ptr) (i64.const 0))

package/module/json.js

@@ -87,12 +87,12 @@ export default (ctx) => {
       const keys = Object.keys(v)
       // Empty object: minimal OBJECT with no slots.
       if (keys.length === 0) {
-        return mkPtrIR(PTR.OBJECT, 0, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', 1], ['i32.const', 8]])
+        return mkPtrIR(PTR.OBJECT, 0, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', 1]])
       }
       const schemaId = ctx.schema.register(keys)
       const t = tempI32('jobj')
       const body = [
-        ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', keys.length], ['i32.const', 8]]],
+        ['local.set', `$${t}`, ['call', '$__alloc_hdr', ['i32.const', 0], ['i32.const', keys.length]]],
       ]
       for (let i = 0; i < keys.length; i++) {
         body.push(['f64.store', slotAddr(t, i), asF64(emitJsonConstValue(v[keys[i]]))])
@@ -582,10 +582,10 @@ export default (ctx) => {
       ;; miss: register new schema.
       (local.set $sid (global.get $__schema_next))
       (global.set $__schema_next (i32.add (local.get $sid) (i32.const 1)))
-      ;; Allocate jz Array of n keys. __alloc_hdr(len, cap, stride) returns base
-      ;; of slot region with len@-8 and cap@-4. The schema dispatch arm reads
+      ;; Allocate jz Array of n keys. __alloc_hdr(len, cap) returns base of
+      ;; slot region with len@-8 and cap@-4. The schema dispatch arm reads
       ;; nkeys from -8, so len must equal cap=n.
-      (local.set $karr (call $__alloc_hdr (local.get $n) (local.get $n) (i32.const 8)))
+      (local.set $karr (call $__alloc_hdr (local.get $n) (local.get $n)))
       (local.set $i (i32.const 0))
       (block $cd (loop $cl
         (br_if $cd (i32.ge_s (local.get $i) (local.get $n)))
@@ -623,7 +623,7 @@ export default (ctx) => {
       (then ${ADV(1)}
         (local.set $sid (call $__jp_schema_get (local.get $kbuf) (i32.const 0) (local.get $hh)))
         (return (call $__mkptr (i32.const ${PTR.OBJECT}) (local.get $sid)
-          (call $__alloc_hdr (i32.const 0) (i32.const 1) (i32.const 8))))))
+          (call $__alloc_hdr (i32.const 0) (i32.const 1))))))
     (block $d (loop $l
       ${WS()}
       (if (i32.eq ${PEEK} (i32.const 34))
@@ -661,7 +661,7 @@ export default (ctx) => {
     (local.set $sid (call $__jp_schema_get (local.get $kbuf) (local.get $kn) (local.get $hh)))
     ;; Allocate OBJECT slot region: kn × 8 bytes, with header (size at -8,
     ;; cap at -4) matching the static-fold path's emitJsonConstValue layout.
-    (local.set $obj (call $__alloc_hdr (i32.const 0) (local.get $kn) (i32.const 8)))
+    (local.set $obj (call $__alloc_hdr (i32.const 0) (local.get $kn)))
     ;; Copy values into OBJECT slots.
     (local.set $i (i32.const 0))
     (block $vd (loop $vl
@@ -749,7 +749,7 @@ export default (ctx) => {
       const sid = ctx.schema.register(keys)
       let body = `${WS()}
     ${expect(123)}
-    (local.set $${obj} (call $__alloc_hdr (i32.const 0) (i32.const ${Math.max(1, keys.length)}) (i32.const 8)))`
+    (local.set $${obj} (call $__alloc_hdr (i32.const 0) (i32.const ${Math.max(1, keys.length)})))`
       keys.forEach((k, i) => {
         body += `
     ${WS()}

package/module/math.js

@@ -13,7 +13,7 @@
  * @module math
  */
 
-import { typed, asF64, asI32, temp, arrayLoop } from '../src/ir.js'
+import { typed, asF64, asI32, toI32, temp, arrayLoop } from '../src/ir.js'
 import { emit } from '../src/emit.js'
 import { inc } from '../src/ctx.js'
 import { repOf } from '../src/analyze.js'
@@ -76,7 +76,22 @@ export default (ctx) => {
     for (const x of rest) r = typed(['f64.max', r, asF64(emit(x))], 'f64')
     return r
   }
-  ctx.core.emit['math.round'] = a => fInt('f64.nearest', a)
+  // f64.nearest is roundTiesToEven; JS Math.round is roundTiesToward+∞. They agree
+  // everywhere except exact half-integers n+0.5 with n even (nearest→n, JS→n+1).
+  // Detect that one case — `nearest(x) === x - 0.5` — and bump by one. (The −0.5→−0
+  // and 0.49999…94→0 edges already match `f64.nearest`.)
+  ctx.core.emit['math.round'] = a => {
+    if (typeof a === 'string' && repOf(a)?.intCertain === true) return asF64(emit(a))
+    const t = temp('rnd'), n = temp('rnd')
+    return typed(['block', ['result', 'f64'],
+      ['local.set', `$${t}`, asF64(emit(a))],
+      ['local.set', `$${n}`, ['f64.nearest', ['local.get', `$${t}`]]],
+      ['select',
+        ['f64.add', ['local.get', `$${n}`], ['f64.const', 1]],
+        ['local.get', `$${n}`],
+        ['f64.eq', ['local.get', `$${n}`], ['f64.sub', ['local.get', `$${t}`], ['f64.const', 0.5]]]],
+    ], 'f64')
+  }
   ctx.core.emit['math.fround'] = a => typed(['f64.promote_f32', ['f32.demote_f64', asF64(emit(a))]], 'f64')
 
   // Sign
@@ -129,8 +144,10 @@ export default (ctx) => {
   // Integer/bit operations: return i32 directly. Consumers `asF64`-rebox at
   // store/return boundaries; consumers staying in i32 (bit chains, i32 locals)
   // skip the convert/trunc round-trip entirely.
-  ctx.core.emit['math.clz32'] = a => typed(['i32.clz', asI32(emit(a))], 'i32')
-  ctx.core.emit['math.imul'] = (a, b) => typed(['i32.mul', asI32(emit(a)), asI32(emit(b))], 'i32')
+  // Operands take ECMAScript ToInt32 (wrapping), not saturation — `Math.imul(x, k)`
+  // with a literal k ≥ 2³¹ must wrap to negative, matching JS, not clamp to INT_MAX.
+  ctx.core.emit['math.clz32'] = a => typed(['i32.clz', toI32(emit(a))], 'i32')
+  ctx.core.emit['math.imul'] = (a, b) => typed(['i32.mul', toI32(emit(a)), toI32(emit(b))], 'i32')
 
   // Random
   ctx.core.emit['math.random'] = () => (inc('math.random'), typed(['call', '$math.random'], 'f64'))