jz 0.8.0 → 0.9.0

package/README.md

@@ -21,8 +21,8 @@ JZ distills **"the good parts"** ([Crockford](https://www.youtube.com/watch?v=_D
 | Good for                     | Not for                   |
 |------------------------------|---------------------------|
 | DSP, audio, synthesis        | UI, DOM, the frontend     |
-| Image, video, pixels         | Servers, APIs, I/O        |
-| Simulation, physics, games   | Async, promises, events   |
+| Image, video, pixels         | Serving HTTP, hot I/O     |
+| Simulation, physics, games   | I/O-bound orchestration   |
 | Parsers, codecs, compression | Dynamic, polymorphic, OOP |
 | Scientific, numeric, ML      | Security crypto, big-ints |
 | Hashing, checksums, RNG      | Glue, plumbing, orchestration |
@@ -35,7 +35,7 @@ Output `.wasm` is portable — run it in any host (browser, Node, Deno, edge, pl
 `npm install jz`
 
 ```js
-import jz, { compile, compileModule, instantiate } from 'jz'
+import jz, { compile, compileModule, instantiate, transform } from 'jz'
 
 // Compile + instantiate
 const { exports: { add } } = jz('export let add = (a, b) => a + b')
@@ -52,6 +52,12 @@ instantiate(mod).exports.f(21)  // 42 — repeat cheaply, no recompile
 const asyncMod = await WebAssembly.compile(wasm)
 const asyncInst = await WebAssembly.instantiate(asyncMod)
 asyncInst.exports.f(21) // 42
+
+// jzify as a standalone source→source transform — the same lowering the
+// compiler runs, printed back as canonical jz (also `import transform from 'jz/transform'`)
+transform('var x = 1; function f() { return x }')
+// → 'const f = () => {\n  return x;\n};\nlet x;\nx = 1;'  (decls hoist, then init order)
+transform(alreadyCanonicalSource, { onlyLowered: true })  // → null (nothing to lower)
 ```
 
 <details>
@@ -151,7 +157,7 @@ Options:
 
 ## Language
 
-JZ is a **strict modern JS subset**. Built-in jzify transform extends support to legacy patterns.
+JZ is a **strict modern JS subset**. Built-in jzify transform extends support to legacy/async patterns.
 
 ```
 ┌────────────────────────────────────────────────────────────────────────┐
@@ -162,18 +168,23 @@ JZ is a **strict modern JS subset**. Built-in jzify transform extends support to
 │ │   try/catch/finally  throw                                         │ │
 │ │   operators  strings  booleans  numbers  arrays  objects  `${}`    │ │
 │ │   Math  Number  String  Array  Object  JSON  RegExp  Symbol  null  │ │
-│ │   ArrayBuffer  DataView  TypedArray  Map  Set                      │ │
+│ │   ArrayBuffer  DataView  TypedArray  Map  Set  Atomics             │ │
 │ │   parseInt  parseFloat  encodeURIComponent  Error  BigInt          │ │
 │ │   console  setTimeout/setInterval  Date  performance               │ │
+│ │   structuredClone  groupBy  Set algebra  iterator helpers          │ │
+│ │   fs.read/write (WASI hosts)  fetch via async host imports         │ │
 │ └────────────────────────────────────────────────────────────────────┘ │
 │ jz default (jzify)                                                     │
 │   var  function  arguments  switch  new Foo()                          │
 │   class  new  this  extends  super  static  #private                   │
+│   function*  yield  yield*  Foo.prototype.m = …                        │
+│   async/await  async function*  for await  Promise  using             │
+│   Symbol.iterator  Symbol.asyncIterator  Symbol.dispose               │
+│   SharedArrayBuffer (→ ArrayBuffer)                                    │
 │   ==  !=  instanceof  undefined  WeakMap  WeakSet                      │
 │                                                                        │
 └────────────────────────────────────────────────────────────────────────┘
 Not supported
-  async/await  Promise  function*  yield
   delete  getters/setters  eval  Function  with
   Proxy  Reflect
   import()  DOM  fetch  Intl  Node APIs
@@ -192,17 +203,51 @@ Each follows one rule: **JZ takes WASM/native conventions over JS edge-cases whe
 - **Objects are fixed-shape structs** — literal keys sit in fixed slots; computed writes (`o[k] = v`) fall back to a per-object hash and enumerate normally, but a dot-key added after the literal (`o.b = 2`) stays readable without enumerating (`Object.keys`/`for…in`). Prefer `Map` for heavy dynamic keys.
 - **Array indices are integers, typed-array access is unchecked** — an index coerces to `i32` (asm.js-style), so a fractional or `NaN` index *truncates* (`a[1.5]`→`a[1]`, `a[NaN]`→`a[0]`) rather than yielding JS's `undefined`. A `Float64Array`/etc. is fixed-size (`arr.length = n` won't compile) and read **raw**: an out-of-bounds or negative index reads arbitrary linear memory (a large one traps), not `undefined` — pass valid in-bounds integers. Plain `[]` arrays *are* bounds-checked (`undefined` past the end / for a negative index).
 - **No GC** — call `memory.reset()` between batches; `WeakMap`/`WeakSet` wired to `Map`/`Set`.
-- **`String(number)` keeps ~9 significant digits** (`String(Math.PI)` → `"3.14159265"`), so it may not round-trip; `NaN`/`Infinity`/integers are exact. Exact shortest-form needs a multi-KB Ryū/Grisu formatter.
+- **Pseudo-classical constructors** — `function P(x) { this.x = x }` + `P.prototype.m = function () {…}` fold into the class lowering automatically (the pre-`class` npm idiom); arrow-valued members keep lexical `this` and stay out.
+- **Generators (sync) + iterator helpers** — `function*`/`yield` compile to regenerator-style state machines (no stack suspension): `next(v)`/`return(v)` are ordinary closure calls, `for-of` over a generator call desugars to a plain loop, and ES2025 helper chains (`g().map(f).filter(p).take(n)`, terminals `toArray`/`reduce`/`some`/`every`/`find`/`forEach`) fuse into ONE loop — no intermediate iterator objects. Helper results are also first-class VALUES (`let evens = nat().filter(even)` then `evens.take(5).toArray()`, `x instanceof Iterator`, `Array.from(iter)`) — helper-using programs mint decorated iterator objects, spec-shaped (value+counter callbacks, lazy, early close). `yield*` delegates to any iterable, `for-of` drives any iterator value (stored machines, hand-rolled `{ next }`, `[Symbol.iterator]()` providers) lazily, and `[...g()]` spreads via the fused path. v1 scope: no `try` across yield — rejects with a precise message.
+- **async/await + Promise, no engine event loop** — an `async` function lowers to the same state machine (`await` ≡ `yield`) driven by a plain-jz promise runtime compiled into the module (pay-per-use: sync programs link none of it). Promises are ordinary fixed-shape objects with `then`/`catch`/`finally`; `Promise.resolve/reject/all/race/allSettled/any/try/withResolvers`, `new Promise(executor)`, and plain-object thenable adoption all work. Async GENERATORS ride the same machine with tagged yields (`async function*`, `yield*` delegation, serialized `next()`), and `for await (x of src)` drives async iterators, sync iterators, and arrays of promises alike. The job queue drains at host boundaries (export return, timer tick) — an async export returns a real host `Promise` that settles when the machine completes (including across `setTimeout` awaits). Divergences: job ordering is per-drain-cycle rather than per-continuation, no unhandled-rejection reporting, no `try` across `await` in v1 (precise reject), and `memory.reset()` while a promise is pending is out of contract.
+- **`fetch` just works** — a bare `fetch(url)` binds from the JS host automatically (no import statement); the `Response` crosses as a live external handle, so `r.text()`/`r.json()` dispatch host-side and are awaitable in turn. Any custom host function returning a `Promise` is likewise awaitable via `{ imports }`. I/O stays host-side (the doctrine), asynchrony crosses the boundary:
+  ```js
+  const { exports } = jz(`
+    export let title = async (url) => {
+      let r = await fetch(url)
+      let body = await r.text()
+      return body.slice(body.indexOf('<title>') + 7, body.indexOf('</title>'))
+    }`)
+  await exports.title('https://example.com')
+  ```
+  Identical in browser and Node — no WASI involved (WASI preview1 has no networking; wasi-http needs the component model, which stays future). Under `--host wasi` a warning tells you to wire `env.fetch` yourself.
+- **Workers v1 (shared-memory SPMD)** — `sharedMemory: true` compiles against a shared `WebAssembly.Memory` (atomic heap bump, wasm `shared` memtype); `Atomics.*` on Int32Array lowers to wasm thread ops (`wait`/`notify` included); `jz.pool(src, {threads})` runs the same kernel across node worker_threads over one memory — annotate shared-array params as `(arr = new Int32Array(0))`. v1 contract: shared typed arrays + scalars; strings/objects stay thread-local.
+- **`String(number)` is ES-spec exact** — shortest round-trip digits via a built-in Ryū formatter (`String(0.1 + 0.2)` → `"0.30000000000000004"`, `String(Math.PI)` → `"3.141592653589793"`), including exponential notation and subnormals; its ~9.7 KB power-of-5 table is lazily included only in modules that stringify floats.
 - **Errors are just their message** — a caught error is the value you threw (no `.message`, not `instanceof Error`), and `null.x` yields `undefined` instead of throwing. It keeps `throw` and member reads free of object machinery and per-access checks.
 - **`Date` getters return UTC** (`getHours` ≡ `getUTCHours`) – the IANA timezone database is hundreds of KB.
 - **`Math.random` is seedable** — default draws host entropy; pass `randomSeed: n` for a reproducible stream.
 </details>
 
+<details>
+<summary><strong>What will JZ never support — and why?</strong></summary>
+
+Everything else is compiled, lowered by the built-in jzify pass, or rejected with a clean error — silent divergence is treated as a bug. These stay out **by design**; each is traded for a zero-cost guarantee:
+
+- **Proxy, Reflect** — traps have no meaning over fixed-shape structs with compile-time-resolved offsets.
+- **Property descriptors & accessors** — `defineProperty` descriptors, getters/setters, `writable`/`enumerable`: objects carry values only, no per-property metadata — that's what makes a property read one load.
+- **Live prototype chains** — `__proto__`, delegation, monkey-patching: `Object.create(proto)` is a documented shallow copy; method dispatch is static.
+- **`delete` on literal-key properties** — an object's shape is fixed at construction (computed-key/dictionary-mode `delete o[k]` works).
+- **eval, `Function` constructor, `with`** — would require the compiler (or an interpreter) at runtime; JZ ships neither.
+- **Intl, Temporal** — ICU/CLDR and timezone tables are hundreds of KB to MB, against single-digit-kB output. `Date` keeps deterministic UTC slices.
+- **UTF-16 string semantics & Unicode tables** — strings are UTF-8 bytes; `\p{…}` classes, `normalize` forms and locale case tables are the same multi-KB cost Intl was refused for.
+- **Arbitrary-precision BigInt** — BigInt is a raw 64-bit integer (wraps past ±2⁶³); bignum chains allocate unboundedly, and security crypto is explicitly out of scope.
+- **WeakRef, FinalizationRegistry** — no GC to observe; `WeakMap`/`WeakSet` fold to `Map`/`Set`.
+- **Annex B legacies, DOM, fetch, Node APIs** — the parts of JS the subset exists to shed; I/O stays host-side.
+
+The litmus for this list: the feature either needs a runtime JZ refuses to ship, or per-access metadata that would tax every program — including the ones not using it.
+</details>
+
 
 <details>
 <summary><strong>Can I use existing npm packages or JS libraries?</strong></summary>
 
-Only the ones that fit the JZ subset. There's no runtime, so packages touching the DOM, `async`/`Promise`, the network, or Node APIs won't compile — but pure numeric/algorithmic source does.
+Only the ones that fit the JZ subset. There's no runtime, so packages touching the DOM or Node APIs won't compile — but pure numeric/algorithmic source does, `async`/`Promise` code included (network calls cross as awaitable host imports, not bundled clients).
 
 - **Relative imports** (`./dep.js`) bundle at compile time.
 - **Bare specifiers** (`import { x } from "pkg"`) resolve through Node module resolution only with the `--resolve` CLI flag, or by passing the source yourself via `{ modules }`. The package's source still has to be valid JZ.
@@ -315,6 +360,8 @@ There's two possible `host` targets:
 - **`js`** (default) — runs inside a JavaScript host (browser, Node, Deno, Bun). `jz()` and `jz/interop` wire the needed `env.*` services automatically (overridable via `opts.imports.env`), and you get full value marshaling across the boundary.
 - **`wasi`** — runs on a standalone WASM engine with no JavaScript (wasmtime, wasmer, deno run). JZ emits WASI Preview 1, so the module needs no host shims — but there's no host-side marshaler, so heap values must be passed by hand.
 
+Under `--host wasi` module init ships as the standard WASI reactor export `_initialize` (never a wasm start section — the p1 ABI forbids WASI calls there). ABI-following hosts (wasmtime, node:wasi `initialize()`, `jz/wasi`, `jz/interop`) call it after wiring memory; instantiating by hand, call `instance.exports._initialize?.()` once before anything else. Command entries (`run`, `_start`) self-init, so invoking them directly also works.
+
 Either way the `.wasm` carries at most one import namespace (none, `env`, or `wasi_snapshot_preview1`). The difference is only in how a few runtime services are serviced:
 
 | What your code does | `js` (default) | `wasi` |
@@ -446,7 +493,7 @@ Literals (`0` vs `0.5`), operators (`|` `<<` `&` ⇒ i32), and how a value is us
 <details>
 <summary><strong>Is JZ production-ready?</strong></summary>
 
-It's **experimental** (pre-1.0) — the supported subset and the wasm ABI may still change, so pin a version and re-test on upgrade. What's solid: every push runs the full test suite, the test262 conformance subset, the benchmark gate, and the self-host build in CI, so regressions surface immediately.
+It's **experimental** (pre-1.0) — the supported subset and the wasm ABI may still change, so pin a version and re-test on upgrade. What's solid: every push runs the full test suite, the test262 conformance slice (≈3,900 language + built-ins files at **0 fail** — every excluded test is skip-classified by name, so a new failure can't hide), the benchmark gate, and the self-host build in CI, so regressions surface immediately.
 
 </details>
 

package/bench/README.md

@@ -53,6 +53,8 @@ node bench/bench.mjs mat4 --targets=nat,v8,jz
 | [`dotprod`](dotprod/dotprod.js) | multiply-accumulate reduction; JZ reassociates to 4 SIMD accumulators, beating strict-fp serial native |
 | [`bytebeat`](bytebeat/bytebeat.js) | classic integer "bytebeat" one-line-song synthesis to 8-bit PCM; pure i32, bit-exact everywhere |
 | [`fft`](fft/fft.js) | radix-2 Cooley–Tukey FFT over a transcendental-free twiddle table; the canonical numeric/audio kernel |
+| [`fftplan`](fftplan/fftplan.js) | the same butterflies through a Map-cached plan object — how every JS DSP lib ships FFT; exposes typed-array kind loss through return values / object fields / params (dynamic element access in the hot loop) |
+| [`provenance`](provenance/provenance.js) | one butterfly kernel over bit-identical tables that differ only in provenance — direct return, returned-object field, Map-cached field, module-global memo; per-edge coverage for the `fftplan` kind-loss class |
 | [`synth`](synth/synth.js) | minisynth audio pipeline — polynomial oscillator + ADSR + biquad per sample; loop-carried f64 |
 | [`blur`](blur/blur.js) | separable box blur on an RGBA8 image; integer stencil with edge clamp, the canonical image pipeline |
 | [`conv2d`](conv2d/conv2d.js) | int8 quantized conv layer (Cin→Cout, 3×3, i32 MAC + ReLU requant); the spatial-convolution counterpart to dense `matmul`, the edge-ML inference kernel |
@@ -70,16 +72,28 @@ node bench/bench.mjs mat4 --targets=nat,v8,jz
 | [`sieve`](sieve/sieve.js) | Sieve of Eratosthenes over a byte array; pure strided scatter (j = i², i²+i, …) guarded by an outer branch — a non-contiguous write pattern |
 | [`vm`](vm/vm.js) | tiny bytecode interpreter — a fetch-decode-dispatch loop (if/else opcode chain + indirect code-array loads) running an integer recurrence; the canonical VM/regex-engine inner loop |
 | [`spmv`](spmv/spmv.js) | sparse matrix×vector in CSR form; the MAC inner loop gathers `x[col[k]]` through a column-index array — the data-dependent gather dense codegen handles worst (exact-integer f64, bit-identical everywhere) |
-| [`hashjoin`](hashjoin/hashjoin.js) | probe-dominated relational hash join (build small, stream a large probe side, sum matched payloads) — the database/dataframe kernel and JZ's boss case: `probe()` returns a typed-array element through a param JZ can't yet prove is i32, so `sum + probe()` lowers to a polymorphic number-or-string add per probe — the only case JZ trails V8; proving the return i32 measured 8.7 → 5.2 ms, jz then beats V8 1.3× |
+| [`hashjoin`](hashjoin/hashjoin.js) | probe-dominated relational hash join (build small, stream a large probe side, sum matched payloads) — the database/dataframe kernel and JZ's boss case: `probe()` returns a typed-array element through a param JZ can't yet prove is i32, so `sum + probe()` lowers to a polymorphic number-or-string add per probe — then the only case JZ trailed V8; proving the return i32 measured 8.7 → 5.2 ms, jz now beats V8 1.3× |
+| [`dispatch`](dispatch/dispatch.js) | data-driven dispatch through a table of 8 first-class functions — one call site fans out per an unpredictable opcode stream; the megamorphic call-site / virtual-dispatch kernel (strategy tables, event pipelines, effect chains), the classic call-IC deopt shape |
+| [`shapes`](shapes/shapes.js) | per-variant measure summed over records of 8 heterogeneous object shapes — every access site sees 8 hidden classes; the megamorphic property-load / hidden-class kernel (JSON rows, AST nodes, ECS entities), the classic load-IC deopt shape — and JZ's widest gap (the schema union falls to dynamic-property probes) |
+| [`strbuild`](strbuild/strbuild.js) | per-record string formatting (`id,name,value\n` per row: int→string + concat + char fold) — the serializer/logger inner loop, the string-allocation deopt shape (a giant `+=` accumulator is deliberately avoided: eager no-GC strings make it quadratic in allocation — jz exhausts memory on it) |
+| [`wordcount`](wordcount/wordcount.js) | token-frequency counting into a plain object with 512 computed string keys over a skewed stream — the group-by/histogram kernel; a JIT drops the object to dictionary mode (the keyed-store deopt), while jz's string-keyed hash store + interning carry it |
+| [`immutable`](immutable/immutable.js) | integer particle step in the immutable-update idiom — every step replaces each record with a fresh `{x,y,vx,vy}` (React/Redux-style state); value-semantics natives get it free, a JIT leans on young-gen GC + escape analysis, jz pays a bump allocation per object — the escape-analysis/SROA probe |
+| [`colorconv`](colorconv/colorconv.js) | sRGB → Oklab over an image buffer — EOTF pow → 3×3 → cbrt → 3×3; lab probe for pow/cbrt intrinsic quality |
+| [`colorlch`](colorlch/colorlch.js) | sRGB → OkLCh fused in one loop (pow → 3×3 → cbrt → 3×3 → sqrt + atan2); lab probe — the fused body must never lose to the split loops |
+| [`colorlog`](colorlog/colorlog.js) | ARRI LogC4 → XYZ — runtime-base exp2 decode + 3×3; lab probe for runtime-exponent pow/exp2 |
+| [`colorpq`](colorpq/colorpq.js) | sRGB → JzAzBz — 3×3 → ST 2084 PQ (≈12 signed-pow) → 3×3; lab probe for signed pow with non-constant exponent |
 | [`watr`](watr/watr.js) | watr's WAT-to-wasm compiler on a small WAT corpus; compares jz-compiled compiler code with raw V8 |
 | [`jessie`](jessie/jessie.js) | the subscript/jessie JS parser over a realistic source corpus; branch-, allocation- and recursion-heavy front-end work |
 | [`jz`](jz/jz.js) | the JZ compiler itself (scripts/self.js pipeline) compiling three small programs at L2 — the self-host row runs jz.wasm compiling JavaScript; output bytes are checksummed so the parity gate doubles as a determinism proof |
 
-The `watr`, `jessie`, and `jz` rows are self-referential — JZ (or its deps)
-compiling code. They stay runnable (`--cases=watr,jessie,jz`) and gated in
-`test/bench.js`, but are hidden from the bench page and the headline geomean SVG:
-they answer a different question (compiler throughput on itself) from the
-cross-language kernel comparison the page is about.
+The **`lab` rows** — the self-referential `watr`/`jessie`/`jz` (JZ or its deps
+compiling code) and the JS-only intrinsic probes `colorconv`/`colorlch`/
+`colorlog`/`colorpq` (pow/cbrt/exp2/atan2 gap trackers with no cross-language
+ports; their transcendental checksums legitimately diverge per libm) — answer
+jz-internal questions, not the cross-language kernel comparison. They sit out
+every aggregate (the geomean SVG, the page strip and geomeans, the aggregate
+table below) but stay visible on the bench page under the `lab` chip and
+runnable via `--cases=…`; the self-host rows stay gated in `test/bench.js`.
 
 Native rows for `json` are fixed-source references, not semantic equivalents
 of JavaScript `JSON.parse`: C/Rust/Zig hand-parse the known schema from a
@@ -210,9 +224,9 @@ wasm-in-V8 would be a wrong-class single-case compare.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **4.64 ms** | **1.94×** | **3.4 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 6.51 ms | 1.38× | 1.9 kB | ok |
-| V8 (node) raw JS | 8.98 ms | 1.00× | 3.2 kB | ok |
+| **JZ → V8 wasm** | **4.68 ms** | **1.94×** | **1.7 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 6.59 ms | 1.38× | 1.8 kB | ok |
+| V8 (node) raw JS | 9.09 ms | 1.00× | 3.2 kB | ok |
 | hand-WAT → V8 wasm | 6.49 ms | 1.90× | 767 B | ok |
 
 JZ beats V8 raw JS by 2.1× and AS by 1.4×. The typed-array scalarization,
@@ -223,9 +237,9 @@ that matches the hand-WAT floor.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **1.49 ms** | **5.75×** | **3.1 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 6.71 ms | 1.28× | 1.6 kB | ok |
-| V8 (node) raw JS | 8.57 ms | 1.00× | 1.2 kB | ok |
+| **JZ → V8 wasm** | **0.77 ms** | **11.15×** | **1.5 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 6.72 ms | 1.28× | 1.4 kB | ok |
+| V8 (node) raw JS | 8.60 ms | 1.00× | 1.2 kB | ok |
 | hand-WAT → V8 wasm | 8.12 ms | 1.47× | 414 B | ok |
 
 JZ is 5.9× faster than V8 raw JS and 4.6× faster than AS. The scalarized
@@ -236,9 +250,9 @@ this from JS source.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **0.13 ms** | **12.67×** | **1.4 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 0.81 ms | 2.07× | 1.3 kB | ok |
-| V8 (node) raw JS | 1.67 ms | 1.00× | 1014 B | ok |
+| **JZ → V8 wasm** | **0.13 ms** | **12.30×** | **1.0 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 0.79 ms | 2.06× | 1.3 kB | ok |
+| V8 (node) raw JS | 1.64 ms | 1.00× | 1014 B | ok |
 
 JZ is 12.9× faster than V8 raw JS and 5.9× faster than AS. The bimorphic
 `sum` (called with both `Float64Array` and `Int32Array`) stays on typed
@@ -248,10 +262,10 @@ paths without falling back to generic dispatch.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **1.01 ms** | **3.84×** | **1.2 kB** | **ok** |
-| V8 (node) raw JS | 3.87 ms | 1.00× | 1005 B | ok |
-| AssemblyScript (asc -O3 --runtime stub) | 9.15 ms | 0.42× | 1.5 kB | ok |
-| hand-WAT → V8 wasm | 3.59 ms | 1.11× | 355 B | ok |
+| **JZ → V8 wasm** | **0.99 ms** | **3.81×** | **1.0 kB** | **ok** |
+| V8 (node) raw JS | 3.77 ms | 1.00× | 1005 B | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 9.11 ms | 0.41× | 1.3 kB | ok |
+| hand-WAT → V8 wasm | 3.49 ms | 1.08× | 355 B | ok |
 
 JZ is 4.0× faster than V8 raw JS and 8.8× faster than AS. The i32 hot path
 (`Math.imul`, `|0`, `>>>0`) now lowers to raw `i32` ops without NaN-box
@@ -261,9 +275,9 @@ overhead on every operation.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **0.06 ms** | **2.26×** | **2.2 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 0.06 ms | 2.15× | 1.6 kB | ok |
-| V8 (node) raw JS | 0.13 ms | 1.00× | 2.0 kB | ok |
+| **JZ → V8 wasm** | **0.06 ms** | **2.16×** | **2.0 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 0.06 ms | 2.13× | 1.5 kB | ok |
+| V8 (node) raw JS | 0.14 ms | 1.00× | 2.0 kB | ok |
 
 JZ is 2.4× faster than V8 raw JS and now edges out AS by ~1.2× on this
 `charCodeAt`-heavy scan. Both are well ahead of V8.
@@ -272,9 +286,9 @@ JZ is 2.4× faster than V8 raw JS and now edges out AS by ~1.2× on this
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **0.26 ms** | **2.37×** | **1.4 kB** | **ok** |
-| V8 (node) raw JS | 0.62 ms | 1.00× | 1.3 kB | ok |
-| AssemblyScript (asc -O3 --runtime stub) | 0.80 ms | 0.78× | 1.9 kB | ok |
+| **JZ → V8 wasm** | **0.27 ms** | **2.25×** | **1.4 kB** | **ok** |
+| V8 (node) raw JS | 0.60 ms | 1.00× | 1.3 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 0.80 ms | 0.76× | 1.8 kB | ok |
 
 JZ is 2.3× faster than V8 raw JS and 2.9× faster than AS. Closure +
 `Array.map` lowers to a preallocated typed loop with no per-iteration alloc.
@@ -284,9 +298,9 @@ V8's JIT does not inline the closure across the `map` boundary.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **0.69 ms** | **1.93×** | **1.8 kB** | **ok** |
-| V8 (node) raw JS | 1.33 ms | 1.00× | 1.1 kB | ok |
-| AssemblyScript (asc -O3 --runtime stub) | 1.40 ms | 0.95× | 2.1 kB | ok |
+| **JZ → V8 wasm** | **0.67 ms** | **2.00×** | **1.7 kB** | **ok** |
+| V8 (node) raw JS | 1.34 ms | 1.00× | 1.1 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 1.40 ms | 0.96× | 1.9 kB | ok |
 
 JZ is 1.9× faster than V8 raw JS and 2.0× faster than AS. Schema-slot
 reads are direct field offsets; the gap is small because the workload is
@@ -296,9 +310,9 @@ memory-bound.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| AssemblyScript (asc -O3 --runtime stub) | 8.90 ms | 1.11× | 1.3 kB | ok |
-| **JZ → V8 wasm** | **8.45 ms** | **1.17×** | **1.4 kB** | **ok** |
-| V8 (node) raw JS | 9.90 ms | 1.00× | 1.8 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 8.85 ms | 1.11× | 1.3 kB | ok |
+| **JZ → V8 wasm** | **8.45 ms** | **1.16×** | **1.1 kB** | **ok** |
+| V8 (node) raw JS | 9.83 ms | 1.00× | 1.8 kB | ok |
 
 JZ is 1.1× faster than V8 raw JS and ties AS. The dense f64 hot loop with
 conditional break compacts to 1.0 kB — the smallest wasm in the suite.
@@ -307,7 +321,7 @@ conditional break compacts to 1.0 kB — the smallest wasm in the suite.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **0.21 ms** | **1.28×** | **9.9 kB** | **ok** |
+| **JZ → V8 wasm** | **0.22 ms** | **1.22×** | **9.7 kB** | **ok** |
 | V8 (node) raw JS | 0.27 ms | 1.00× | 1.2 kB | ok |
 
 JZ is 1.3× faster than V8 raw JS. The runtime parser is specialized to the
@@ -317,9 +331,9 @@ inferred JSON shape; AS is skipped because it cannot parse JSON at runtime.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **4.65 ms** | **1.67×** | **1.8 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 7.96 ms | 0.98× | 1.9 kB | ok |
-| V8 (node) raw JS | 7.79 ms | 1.00× | 1.6 kB | ok |
+| **JZ → V8 wasm** | **5.41 ms** | **1.64×** | **1.6 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 7.93 ms | 1.12× | 1.8 kB | ok |
+| V8 (node) raw JS | 8.87 ms | 1.00× | 1.6 kB | ok |
 
 JZ is 1.6× faster than V8 raw JS and 1.4× faster than AS. Call-heavy
 nested loops with typed-array index propagation stay on the i32 path.
@@ -328,9 +342,9 @@ nested loops with typed-array index propagation stay on the i32 path.
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| **JZ → V8 wasm** | **8.74 ms** | **1.11×** | **1.5 kB** | **ok** |
-| AssemblyScript (asc -O3 --runtime stub) | 8.76 ms | 1.11× | 1.4 kB | ok |
-| V8 (node) raw JS | 9.71 ms | 1.00× | 1.8 kB | ok |
+| **JZ → V8 wasm** | **8.62 ms** | **1.12×** | **1.0 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 8.74 ms | 1.10× | 1.3 kB | ok |
+| V8 (node) raw JS | 9.62 ms | 1.00× | 1.8 kB | ok |
 
 JZ is 1.2× faster than V8 raw JS and ties AS. Integer narrowing and
 typed-array parameter propagation keep the LUT lookup on raw i32.
@@ -419,12 +433,64 @@ dependent-gather / branchy-DP** kernels, not in dense scalar or dispatch loops.
 Like the batch above, these stay bench-only (out of `test/bench.js`) until the gap
 closes.
 
+### Deopt kernels — dispatch, shapes, strings, maps, allocation
+
+Five cases aimed square at the *deoptimization* shapes — the dynamic patterns
+that make a JIT bail out of optimized code, and that an AOT compiler must
+instead resolve statically. All are bit-identical across every target and
+data-shuffled, so no branch predictor, inline cache, or devirtualizer can
+settle on a fast path. Together they cover the dynamic-JS surface jz commits to
+compile well: **calls** (`dispatch` — one call site fans out to a table of 8
+first-class functions, the megamorphic call-IC shape), **hidden classes**
+(`shapes` — records of 8 heterogeneous object shapes at one access site, the
+megamorphic load-IC shape), **string churn** (`strbuild` — per-record
+int→string + concat, the serializer inner loop), **keyed maps** (`wordcount` —
+counting into a plain object with 512 computed string keys, the
+dictionary-mode keyed-store deopt), and **allocation** (`immutable` — a fresh
+`{x,y,vx,vy}` per particle per step, the React/Redux-style immutable update).
+The static rivals write what a static language writes: fn-pointer tables,
+tagged unions, stack-buffer formatting, string hash maps, value-type structs.
+
+| case | JZ | vs V8 | vs AS | vs native C | what it probes |
+| --- | ---: | ---: | ---: | ---: | --- |
+| **dispatch** — fn-table dispatch | **10.4 ms** | 0.84× | **1.23×** | 0.46× | `call_indirect` vs megamorphic call IC |
+| **strbuild** — per-record formatting | 1.83 ms | 0.92× | 0.83× | 0.83× | int→string + concat temporaries |
+| **wordcount** — string-keyed counting | 8.80 ms | 0.30× | 0.93× | 0.28× | dynamic keys vs dictionary-mode IC |
+| **immutable** — fresh-object step | 1.32 ms | 0.33× | 0.52× | 0.06× | escape analysis / allocation churn |
+| **shapes** — 8-shape record scan | 18.1 ms | 0.19× | 0.06× | 0.09× | schema-union access vs megamorphic load IC |
+
+The probes split jz's dynamic story cleanly. On `dispatch` **jz leads the
+systems-language wasm field** — AS 1.23×, Rust/C/Zig/Go→wasm 1.05–1.2× — its
+data-selected `call_indirect` is already tighter than what the systems
+languages ship through the same table (only MoonBit's moonrun row edges it);
+the remaining field is JIT call machinery — V8 0.84×, and JavaScriptCore's
+call ICs win the case outright at ~2.3 ms — with bounded-table devirt (guarded
+direct calls over the 8 known closures) the lever to close it. `strbuild` is
+near-parity with V8 but rust-wasm leads 1.3× (and zig-wasm's stack-buffer
+formatting 4.5×) — per-temporary `__str_concat` allocation and generic
+`__itoa` are the levers. (The giant `out +=` accumulator variant is
+deliberately excluded: eager no-GC strings make it quadratic in allocation —
+jz exhausts memory on it. A real landmine for jz users, documented in the
+case header.) `wordcount` ties AS's Map while V8's dictionary mode runs 3.3×
+ahead and a plain C strcmp table 10× — per-op string hashing is the gap,
+interning the lever. `immutable` trails every rival — jz bump-allocates each
+escaping object with no scalar replacement and no reclamation, where V8's
+young-gen GC recycles and value-semantics natives never allocate at all.
+`shapes` stays **the widest gap in the suite, by design**: the 8-schema union
+defeats schema-slot inference, so every field read lowers through the
+`__dyn_get` dynamic-property probe — ~5× behind V8's megamorphic IC and ~16×
+behind AS's kind-tagged flat struct (which ties native C); the general fix is
+shape-set devirt — a bounded schema union lowering to a tag-switch over direct
+slot loads, the static mirror of a polymorphic IC. `dispatch` passes the
+fastest-wasm gate; `shapes`, `wordcount`, `immutable`, and `strbuild` are
+pinned red in `WASM_TODO` — the deopt work list, loudest first.
+
 ### watr — WAT-to-wasm compiler on small corpus
 
 | target | median | ×v8 | size | parity |
 | --- | ---: | ---: | ---: | --- |
-| V8 (node) raw JS | 1.38 ms | 1.00× | 2.6 kB | ok |
-| **JZ → V8 wasm** | **1.17 ms** | **1.17×** | **238.4 kB** | **ok** |
+| V8 (node) raw JS | 0.97 ms | 1.00× | 2.6 kB | ok |
+| **JZ → V8 wasm** | **0.96 ms** | **1.00×** | **244.3 kB** | **DIFF** |
 
 JZ is 1.07× slower than V8 raw JS on this large compiler bundle. The size
 (144 kB) is the full jz-compiled watr parser + encoder + optimizer; V8's JIT
@@ -436,19 +502,24 @@ Aggregate geomean (JZ / target):
 
 | target | speed | size |
 | --- | ---: | ---: |
-| V8 (node) | **0.40×** | — |
-| AssemblyScript | **0.36×** | **1.16×** |
+| V8 (node) | **0.53×** | — |
+| AssemblyScript | **0.58×** | **1.06×** |
 
-JZ wins or ties V8 on every kernel case; the only V8 losses are the
-self-hosting rows `watr` (1.07×) and `jessie` (1.28×). AS is beaten on
-speed across the shared cases. On size JZ is ~1.1× AS (geomean 1.16×,
-median 1.10×) — JZ wins on speed, AS on bytes.
+JZ wins or ties V8 on every dense kernel case; the open V8 losses are the
+self-host lab rows (`watr`, `jessie`) and the deliberate deopt probes above
+(`dispatch`, `shapes`, `wordcount`, `immutable`, `strbuild` — the dynamic-JS
+work list). AS is beaten on speed across the shared cases except the tracked
+gather/probe gaps (`dict`, `noise`, `levenshtein`) and the deopt probes
+(`shapes`, `immutable`, `strbuild`; `wordcount` is a tie). On size JZ matches
+AS (geomean ~1.0×) — JZ wins on speed and holds size parity.
 
 Against the systems languages compiled to the same target — **WebAssembly, run in
-V8** — JZ is **2.4× faster than C, 2.6× than Rust, and 4.8× than Go** (geomean).
-That apples-to-apples wasm field is the headline chart above, and JZ holds
-**geomean parity with native `clang -O3`** itself (1.11×) — the lone non-wasm
-reference row, the speed-of-light ceiling, never a per-case beat-claim.
+V8** — JZ is **1.6× faster than C, 1.7× than Rust, and 3.4× than Go** (geomean,
+deopt probes included). That apples-to-apples wasm field is the headline chart
+above. Native `clang -O3` — the lone non-wasm reference row, the speed-of-light
+ceiling, never a per-case beat-claim — now leads the corpus geomean 1.2×: the
+deopt probes are exactly where native value semantics and mature runtimes pull
+ahead, and closing them is the current work list.
 
 Case-by-case summary:
 

package/bench/bench.svg

@@ -1,14 +1,14 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 424" width="720" height="424" style="color-scheme:light dark" role="img" aria-label="JZ benchmark — every rival compiled to WebAssembly, run in V8 · native C = reference; geometric mean across 38 benchmark cases · lower is faster, JZ = 1.00× baseline; each ball's speed is proportional to that engine's geometric-mean runtime across the corpus">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 424" width="720" height="424" style="color-scheme:light dark" role="img" aria-label="JZ benchmark — every rival compiled to WebAssembly, run in V8 · native C = reference; geometric mean across 45 benchmark cases · lower is faster, JZ = 1.00× baseline; each ball's speed is proportional to that engine's geometric-mean runtime across the corpus">
 
   <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
     <rect x="174" y="43.5" width="476" height="3" rx="1.5" fill="currentColor" fill-opacity="0.1"/>
     <line x1="174" y1="38" x2="174" y2="52" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <line x1="650" y1="38" x2="650" y2="52" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
-    <text x="156" y="41" text-anchor="end" font-size="14" font-weight="700" fill="currentColor" fill-opacity="1">JZ</text>
-    <text x="156" y="56" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">-O3</text>
-    <text x="662" y="49" font-size="13" font-weight="700" fill="currentColor" fill-opacity="1">1.00×</text>
-    <circle cx="182.0" cy="45" r="8" fill="currentColor" fill-opacity="1">
-      <animate attributeName="cx" dur="1.6s" repeatCount="indefinite" calcMode="linear"
+    <text x="156" y="41" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">native C</text>
+    <text x="156" y="56" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">clang -O3 · ref</text>
+    <text x="662" y="49" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">0.82×</text>
+    <circle cx="182.0" cy="45" r="8" fill="currentColor" fill-opacity="0.4">
+      <animate attributeName="cx" dur="1.3125489894306868s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.00s"/>
     </circle>
   </g>
@@ -16,11 +16,11 @@
     <rect x="174" y="93.5" width="476" height="3" rx="1.5" fill="currentColor" fill-opacity="0.1"/>
     <line x1="174" y1="88" x2="174" y2="102" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <line x1="650" y1="88" x2="650" y2="102" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
-    <text x="156" y="91" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">native C</text>
-    <text x="156" y="106" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">clang -O3 · ref</text>
-    <text x="662" y="99" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">1.01×</text>
-    <circle cx="182.0" cy="95" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="1.6171275085641825s" repeatCount="indefinite" calcMode="linear"
+    <text x="156" y="91" text-anchor="end" font-size="14" font-weight="700" fill="currentColor" fill-opacity="1">JZ</text>
+    <text x="156" y="106" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">-O3</text>
+    <text x="662" y="99" font-size="13" font-weight="700" fill="currentColor" fill-opacity="1">1.00×</text>
+    <circle cx="182.0" cy="95" r="8" fill="currentColor" fill-opacity="1">
+      <animate attributeName="cx" dur="1.6s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.41s"/>
     </circle>
   </g>
@@ -30,9 +30,9 @@
     <line x1="650" y1="138" x2="650" y2="152" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <text x="156" y="141" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">C</text>
     <text x="156" y="156" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">clang → wasm</text>
-    <text x="662" y="149" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">2.01×</text>
+    <text x="662" y="149" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">1.64×</text>
     <circle cx="182.0" cy="145" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="3.214848718379708s" repeatCount="indefinite" calcMode="linear"
+      <animate attributeName="cx" dur="2.624757929306874s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.82s"/>
     </circle>
   </g>
@@ -40,11 +40,11 @@
     <rect x="174" y="193.5" width="476" height="3" rx="1.5" fill="currentColor" fill-opacity="0.1"/>
     <line x1="174" y1="188" x2="174" y2="202" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <line x1="650" y1="188" x2="650" y2="202" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
-    <text x="156" y="191" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">Rust</text>
-    <text x="156" y="206" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">rustc → wasm</text>
-    <text x="662" y="199" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">2.05×</text>
+    <text x="156" y="191" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">AssemblyScript</text>
+    <text x="156" y="206" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">asc -O3</text>
+    <text x="662" y="199" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">1.73×</text>
     <circle cx="182.0" cy="195" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="3.2852220400953436s" repeatCount="indefinite" calcMode="linear"
+      <animate attributeName="cx" dur="2.7633688737454363s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.23s"/>
     </circle>
   </g>
@@ -52,11 +52,11 @@
     <rect x="174" y="243.5" width="476" height="3" rx="1.5" fill="currentColor" fill-opacity="0.1"/>
     <line x1="174" y1="238" x2="174" y2="252" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <line x1="650" y1="238" x2="650" y2="252" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
-    <text x="156" y="241" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">AssemblyScript</text>
-    <text x="156" y="256" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">asc -O3</text>
-    <text x="662" y="249" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">2.10×</text>
+    <text x="156" y="241" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">Rust</text>
+    <text x="156" y="256" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">rustc → wasm</text>
+    <text x="662" y="249" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">1.73×</text>
     <circle cx="182.0" cy="245" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="3.3536253223690404s" repeatCount="indefinite" calcMode="linear"
+      <animate attributeName="cx" dur="2.77333545752851s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.64s"/>
     </circle>
   </g>
@@ -66,9 +66,9 @@
     <line x1="650" y1="288" x2="650" y2="302" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <text x="156" y="291" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">V8</text>
     <text x="156" y="306" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">Node (JS)</text>
-    <text x="662" y="299" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">2.33×</text>
+    <text x="662" y="299" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">1.90×</text>
     <circle cx="182.0" cy="295" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="3.72980153913452s" repeatCount="indefinite" calcMode="linear"
+      <animate attributeName="cx" dur="3.0407840012463723s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.05s"/>
     </circle>
   </g>
@@ -77,13 +77,13 @@
     <line x1="174" y1="338" x2="174" y2="352" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <line x1="650" y1="338" x2="650" y2="352" stroke="currentColor" stroke-opacity="0.3" stroke-width="2"/>
     <text x="156" y="341" text-anchor="end" font-size="14" font-weight="500" fill="currentColor" fill-opacity="0.82">Porffor</text>
-    <text x="156" y="356" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">runs 4 / 38</text>
-    <text x="662" y="349" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">3.76×</text>
+    <text x="156" y="356" text-anchor="end" font-size="10" fill="currentColor" fill-opacity="0.46">runs 4 / 45</text>
+    <text x="662" y="349" font-size="13" font-weight="500" fill="currentColor" fill-opacity="0.6">3.27×</text>
     <circle cx="182.0" cy="345" r="8" fill="currentColor" fill-opacity="0.4">
-      <animate attributeName="cx" dur="6.023170795143817s" repeatCount="indefinite" calcMode="linear"
+      <animate attributeName="cx" dur="5.225740832087161s" repeatCount="indefinite" calcMode="linear"
         keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.46s"/>
     </circle>
   </g>
   <text x="360" y="390" text-anchor="middle" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="11" font-weight="600" fill="currentColor" fill-opacity="0.72">every rival compiled to WebAssembly, run in V8 · native C = reference</text>
-  <text x="360" y="408" text-anchor="middle" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="11" fill="currentColor" fill-opacity="0.5">geometric mean across 38 benchmark cases · lower is faster, JZ = 1.00× baseline</text>
+  <text x="360" y="408" text-anchor="middle" font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif" font-size="11" fill="currentColor" fill-opacity="0.5">geometric mean across 45 benchmark cases · lower is faster, JZ = 1.00× baseline</text>
 </svg>

package/cli.js

@@ -132,7 +132,9 @@ async function handleJzify(args) {
   if (!inputFile) throw new Error('No input file specified')
   if (!outputFile) outputFile = inputFile.replace(/\.js$/, '.jz')
   const code = readFileSync(inputFile, 'utf8')
-  const out = transform(code) + '\n'
+  const warnings = { entries: [] }
+  const out = transform(code, { warnings }) + '\n'
+  for (const w of warnings.entries) console.warn(formatWarning(w))
   if (outputFile === '-') {
     process.stdout.write(out)
   } else {