jz 0.5.1 → 0.6.0

package/bench/README.md

@@ -0,0 +1,319 @@
+# jz benchmark suite
+
+Cross-target workload suite for jz codegen quality. Each benchmark is a case
+folder under `bench/`:
+
+```txt
+bench/<case>/<case>.js      JavaScript source used by V8, jz, etc.
+bench/<case>/<case>.c       optional native C baseline
+bench/<case>/<case>.rs      optional Rust baseline
+bench/<case>/<case>.go      optional Go baseline
+bench/<case>/<case>.zig     optional Zig baseline
+bench/<case>/<case>.as.ts   optional AssemblyScript baseline
+bench/<case>/<case>.py      optional scalar CPython baseline
+bench/<case>/<case>.npy.py  optional NumPy baseline
+bench/<case>/<case>.wat     optional hand-written WAT baseline
+```
+
+Every case prints the same line:
+
+```txt
+median_us=<int> checksum=<u32> samples=<int> stages=<int> runs=<int>
+```
+
+The orchestrator runs selected cases against selected targets and flags checksum
+drift as `DIFF`.
+
+## Run
+
+```sh
+npm run bench
+node bench/bench.mjs --targets=nat,rust,go,numpy,v8,jz
+node bench/bench.mjs --targets=jz --cases=biquad,mat4,poly,bitwise
+node bench/bench.mjs --targets=v8,deno,bun,spidermonkey,hermes,graaljs,qjs
+node bench/bench.mjs --cases=biquad,mat4,tokenizer,json,sort,crc32
+node bench/bench.mjs biquad
+node bench/bench.mjs mat4 --targets=nat,v8,jz
+```
+
+## Cases
+
+| id | purpose |
+| --- | --- |
+| [`biquad`](biquad/biquad.js) | DSP filter cascade; dense f64 typed-array loop and offset-fusion baseline |
+| [`mat4`](mat4/mat4.js) | fixed-size typed-array loops; exposes loop unrolling and offset fusion gaps |
+| [`poly`](poly/poly.js) | same `sum` called with `Float64Array` and `Int32Array`; exposes bimorphic typed-array dispatch |
+| [`bitwise`](bitwise/bitwise.js) | long `i32` narrowing chains with `Math.imul`, shifts, and unsigned conversion |
+| [`tokenizer`](tokenizer/tokenizer.js) | string-heavy scan with `charCodeAt`, branches, and integer token accumulation |
+| [`callback`](callback/callback.js) | `Array.map` callback path; exposes closure/call-indirect and array allocation cost |
+| [`aos`](aos/aos.js) | array-of-object rows copied into typed arrays; exposes schema-slot read cost |
+| [`mandelbrot`](mandelbrot/mandelbrot.js) | 256×256 escape-time iteration; dense f64 hot loop with conditional break and i32 counter |
+| [`json`](json/json.js) | runtime `JSON.parse` of one module-local source plus heterogeneous object/array walk with a stable inferred JSON shape |
+| [`sort`](sort/sort.js) | in-place heapsort over a typed array; exposes call-heavy nested loops and typed-array index propagation |
+| [`crc32`](crc32/crc32.js) | table-driven CRC-32 over a mutable byte buffer; exposes integer narrowing and typed-array parameter propagation |
+| [`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 |
+
+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
+compile-time string, and Zig may constant-fold the whole parse+walk under
+ReleaseFast; Go uses `encoding/json` but still unmarshals the same compile-time
+string. The jz row parses a `let` source at runtime so `JSON.parse` is not
+compile-time folded, while the compiler can still specialize the stable literal
+shape. External unknown-shape JSON still uses the generic runtime parser.
+
+Native-language rows are intentionally per case. NumPy rows are used only
+where a vectorized array implementation is a meaningful Python convention;
+scalar CPython is kept to the tokenizer row to avoid turning the suite into
+a Python loop-overhead benchmark.
+
+### Parity classes
+
+The `parity` column is `ok` when the run's checksum matches the most common
+checksum across all targets, `DIFF` when it diverges in a way that suggests
+a bug, and `fma` when the divergence is the documented FMA-fusion class.
+The Go arm64 backend auto-fuses `a*b + c` to `FMADDD` (mandatory in ARMv8,
+no compiler flag to disable it), which alters bit-level rounding on
+recurrence-style loops like `biquad`. Result is still IEEE-754
+correctly-rounded; cascade is the same algorithm.
+
+## Targets
+
+| id | what it measures |
+| --- | --- |
+| `nat` | clang `-O3` native C baseline, when a matching C workload exists |
+| `natgcc` | gcc `-O3`, when real gcc is installed |
+| `rust` | Rust `rustc -C opt-level=3 -C target-cpu=native`, when a matching `.rs` exists |
+| `go` | Go native compiler, when a matching `.go` exists |
+| `zig` | Zig `build-exe -O ReleaseFast`, when a matching `.zig` exists |
+| `python` | scalar CPython, when a matching `.py` exists |
+| `numpy` | vectorized NumPy, when a matching `.npy.py` exists |
+| `v8` | raw JavaScript on Node/V8 |
+| `deno` | raw JavaScript on Deno/V8 |
+| `bun` | raw JavaScript on Bun/JavaScriptCore |
+| `spidermonkey` | raw JavaScript on SpiderMonkey shell (`spidermonkey`, `sm`, `js128`, `js115`, `js102`, or `js`) |
+| `hermes` | raw JavaScript on Hermes |
+| `shermes` | Static Hermes — JS AOT-compiled to a native binary (`shermes -O`), when installed |
+| `graaljs` | raw JavaScript on GraalJS |
+| `jz` | jz output with host imports for timing/logging (measures wasm size without WASI console/perf bloat) |
+| `as` | AssemblyScript `asc -O3 --runtime stub`, when a matching `.as.ts` exists |
+| `jz-wasmtime` | jz output on wasmtime |
+| `jz-w2c` | jz wasm translated by wabt `wasm2c`, then clang `-O3` |
+| `wat` | hand-written WAT baseline when a case provides `run-wat.mjs` |
+| `qjs` | QuickJS when installed |
+| `porf` | Porffor (`porf run`) when installed |
+| `jawsm` | jawsm when installed |
+
+The `size` column reports the artifact size each target measures: the
+compiled native binary for `nat`/`rust`/`go`/`zig`, the produced
+`.wasm` for `jz`/`as`/hand-WAT/jawsm/`jz-w2c` (the C-translated
+executable), or the source file for raw-JS interpreters where there is no
+compile step. For source files with imports, raw-JS size is only the entry file;
+jz size is the bundled wasm artifact.
+
+Note the preset trade: these speed tables build jz at the default
+(`optimize: 2`, speed-leaning — loop unroll + SIMD lift), while the dedicated
+size comparison (`npm run bench:size`) builds with `optimize: 'size'` —
+typically ~2× smaller on the same kernel (biquad: 3.5 kB default vs 1.6 kB
+size-tuned). Pick the preset for what you ship; the two tables are not the
+same artifact.
+
+Runtime command overrides:
+
+`watr` is intentionally compiled by jz with a size-oriented pass config
+(`watr:false`, `smallConstForUnroll:false`): on a large compiler bundle, the
+default WAT-level optimizer and small-loop unroll grow code more than they help.
+This keeps the target measuring the best current jz artifact for that workload.
+
+```sh
+BUN_BIN=/path/to/bun \
+DENO_BIN=/path/to/deno \
+SPIDERMONKEY_BIN=/path/to/js \
+HERMES_BIN=/path/to/hermes \
+SHERMES_BIN=/path/to/shermes \
+GRAALJS_BIN=/path/to/graaljs \
+PORF_BIN=/path/to/porf \
+node bench/bench.mjs --targets=bun,deno,spidermonkey,hermes,shermes,graaljs,porf
+```
+
+## Reading the numbers (darwin/arm64, M-class)
+
+Snapshots from `node bench/bench.mjs --targets=v8,jz,as`.
+Where jz lands relative to **V8 raw JS** (`v8/node`) and **AssemblyScript**
+(`as`) is the headline comparison. Native and hand-WAT rows are shown where
+available from earlier runs.
+
+### biquad — f64 typed-array DSP cascade
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **6.50 ms** | **1.90×** | **3.4 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 9.03 ms | 1.38× | 1.9 kB | ok |
+| V8 (node) raw JS | 12.35 ms | 1.00× | 3.2 kB | ok |
+| native C (clang -O3) | 5.32 ms | 2.32× | 32.7 kB | ok |
+| hand-WAT → V8 wasm | 6.49 ms | 1.90× | 767 B | ok |
+
+jz beats V8 raw JS by 1.9× and AS by 1.4×. The typed-array scalarization,
+offset-fusion, and base-hoisting pipeline delivers dense-f64 loop codegen
+that matches the hand-WAT floor.
+
+### mat4 — fixed-size Float64Array multiply
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **2.74 ms** | **4.37×** | **3.3 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 9.32 ms | 1.28× | 1.6 kB | ok |
+| V8 (node) raw JS | 11.96 ms | 1.00× | 1.2 kB | ok |
+| native C (clang -O3) | 2.76 ms | 4.33× | 32.8 kB | ok |
+| hand-WAT → V8 wasm | 8.12 ms | 1.47× | 414 B | ok |
+
+jz is 4.4× faster than V8 raw JS and 3.4× faster than AS. The scalarized
+SIMD hot path (unrolled 4×4 multiply) is the win; V8's JIT doesn't vectorize
+this from JS source.
+
+### poly — bimorphic typed-array reduce
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.37 ms** | **6.22×** | **1.2 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 1.15 ms | 2.02× | 1.3 kB | ok |
+| V8 (node) raw JS | 2.32 ms | 1.00× | 1014 B | ok |
+
+jz is 6.2× faster than V8 raw JS and 3.1× faster than AS. The bimorphic
+`sum` (called with both `Float64Array` and `Int32Array`) stays on typed
+paths without falling back to generic dispatch.
+
+### bitwise — i32 narrowing chains (`Math.imul`, shifts, FNV-1a)
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **1.40 ms** | **3.81×** | **1.2 kB** | **ok** |
+| V8 (node) raw JS | 5.32 ms | 1.00× | 1005 B | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 12.13 ms | 0.44× | 1.5 kB | ok |
+| native C (clang -O3) | 1.31 ms | 4.06× | 32.9 kB | ok |
+| hand-WAT → V8 wasm | 4.88 ms | 1.09× | 355 B | ok |
+
+jz is 3.8× faster than V8 raw JS and 8.7× faster than AS. The i32 hot path
+(`Math.imul`, `|0`, `>>>0`) now lowers to raw `i32` ops without NaN-box
+overhead on every operation.
+
+### tokenizer — string scan with `charCodeAt` and integer accumulation
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| AssemblyScript (asc -O3 --runtime stub) | 0.08 ms | 2.63× | 1.6 kB | ok |
+| **jz → V8 wasm** | **0.10 ms** | **2.03×** | **1.7 kB** | **ok** |
+| V8 (node) raw JS | 0.21 ms | 1.00× | 2.0 kB | ok |
+
+jz is 2.0× faster than V8 raw JS. AS wins here by 1.3× because its
+`String#charCodeAt` is a direct memory load without NaN-box decode, while
+jz still boxes the string pointer. The gap is narrow (0.02 ms) and both
+are well ahead of V8.
+
+### callback — `Array.map` closure + i32 fold
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.03 ms** | **27.56×** | **1.4 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 1.49 ms | 0.59× | 1.9 kB | ok |
+| V8 (node) raw JS | 0.88 ms | 1.00× | 828 B | ok |
+
+jz is 27.6× faster than V8 raw JS and 49.7× faster than AS. Closure +
+`Array.map` lowers to a preallocated typed loop with no per-iteration alloc.
+V8's JIT does not inline the closure across the `map` boundary.
+
+### aos — array-of-object rows to typed arrays
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **1.62 ms** | **1.12×** | **1.8 kB** | **ok** |
+| V8 (node) raw JS | 1.82 ms | 1.00× | 1.1 kB | ok |
+| AssemblyScript (asc -O3 --runtime stub) | 1.91 ms | 0.95× | 2.2 kB | ok |
+
+jz is 1.1× faster than V8 raw JS and 1.2× faster than AS. Schema-slot
+reads are direct field offsets; the gap is small because the workload is
+memory-bound.
+
+### mandelbrot — 256×256 escape-time iteration
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| AssemblyScript (asc -O3 --runtime stub) | 12.42 ms | 1.11× | 1.3 kB | ok |
+| **jz → V8 wasm** | **12.55 ms** | **1.10×** | **1.0 kB** | **ok** |
+| V8 (node) raw JS | 13.80 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.
+
+### json — runtime `JSON.parse` plus stable-shape walk
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **0.23 ms** | **1.65×** | **7.7 kB** | **ok** |
+| V8 (node) raw JS | 0.38 ms | 1.00× | 1.2 kB | ok |
+
+jz is 1.7× faster than V8 raw JS. The runtime parser is specialized to the
+inferred JSON shape; AS is skipped because it cannot parse JSON at runtime.
+
+### sort — in-place heapsort over typed array
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **5.96 ms** | **1.87×** | **1.6 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 10.22 ms | 1.09× | 1.9 kB | ok |
+| V8 (node) raw JS | 11.13 ms | 1.00× | 1.6 kB | ok |
+
+jz is 1.9× faster than V8 raw JS and 1.7× faster than AS. Call-heavy
+nested loops with typed-array index propagation stay on the i32 path.
+
+### crc32 — table-driven CRC-32 over byte buffer
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| **jz → V8 wasm** | **12.12 ms** | **1.11×** | **1.2 kB** | **ok** |
+| AssemblyScript (asc -O3 --runtime stub) | 12.19 ms | 1.10× | 1.4 kB | ok |
+| V8 (node) raw JS | 13.43 ms | 1.00× | 1.8 kB | ok |
+
+jz is 1.1× faster than V8 raw JS and ties AS. Integer narrowing and
+typed-array parameter propagation keep the LUT lookup on raw i32.
+
+### watr — WAT-to-wasm compiler on small corpus
+
+| target | median | ×v8 | size | parity |
+| --- | ---: | ---: | ---: | --- |
+| V8 (node) raw JS | 1.45 ms | 1.00× | 2.6 kB | ok |
+| **jz → V8 wasm** | **1.56 ms** | **1.07×** | **144.4 kB** | **ok** |
+
+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
+has the advantage of profile-guided tiering on a long-running compiler.
+
+### Where the gaps live
+
+Aggregate geomean (jz / target):
+
+| target | speed | size |
+| --- | ---: | ---: |
+| V8 (node) | **0.41×** | — |
+| AssemblyScript | **0.40×** | **0.85×** |
+| Porffor | **0.32×** | **0.04×** |
+| wasm-opt slack | — | **0.91×** |
+
+jz wins or ties V8 on every case except `watr` (1.07×). AS is beaten on
+all cases except `tokenizer` (AS 0.08 ms vs jz 0.10 ms). The size geomean
+is 0.85× AS — jz output is smaller on average despite beating AS on speed.
+
+Case-by-case summary:
+
+* **biquad, mat4, poly, bitwise, callback: large wins.** jz beats V8 by
+  1.9–27.6× and AS by 1.4–49.7×. Typed-array scalarization, i32 narrowing,
+  and closure lowering are the drivers.
+* **tokenizer, aos, mandelbrot, sort, crc32: modest wins.** jz beats V8 by
+  1.1–2.0× and ties or beats AS. These are memory-bound or branch-heavy
+  workloads where codegen quality matters less than data layout.
+* **json: solid win.** jz beats V8 by 1.7× on runtime JSON parsing; AS
+  cannot run this case.
+* **watr: near parity.** jz is 1.07× slower than V8 on a 144 kB compiler
+  bundle. This is the only case where V8's profile-guided JIT tiers beat
+  jz's AOT wasm.

package/bench/bench.svg

@@ -0,0 +1,112 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 500" width="720" height="500" role="img" aria-label="jz benchmark — each ball runs back and forth at a rate proportional to that engine's speed; jz is the 1.00× baseline, lower is faster">
+  <rect width="720" height="500" rx="12" fill="#ffffff"/>
+
+  <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="#edf0f2"/>
+    <line x1="174" y1="38" x2="174" y2="52" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="38" x2="650" y2="52" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="41" text-anchor="end" font-size="14" font-weight="700" fill="#000000">jz</text>
+    <text x="156" y="56" text-anchor="end" font-size="10" fill="#aeb4ba">→ wasm</text>
+    <text x="662" y="49" font-size="13" font-weight="700" fill="#000000">1.00×</text>
+    <circle cx="182.0" cy="45" r="8" fill="#000000">
+      <animate attributeName="cx" dur="1.6s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.00s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="93.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="88" x2="174" y2="102" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="88" x2="650" y2="102" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="91" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Rust</text>
+    <text x="156" y="106" text-anchor="end" font-size="10" fill="#aeb4ba">rustc -O3</text>
+    <text x="662" y="99" font-size="13" font-weight="500" fill="#868e96">1.07×</text>
+    <circle cx="182.0" cy="95" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="1.7111717105322697s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.41s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="143.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="138" x2="174" y2="152" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="138" x2="650" y2="152" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="141" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Zig</text>
+    <text x="156" y="156" text-anchor="end" font-size="10" fill="#aeb4ba">ReleaseFast</text>
+    <text x="662" y="149" font-size="13" font-weight="500" fill="#868e96">1.31×</text>
+    <circle cx="182.0" cy="145" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="2.097403438402887s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-0.82s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="193.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="188" x2="174" y2="202" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="188" x2="650" y2="202" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="191" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Bun</text>
+    <text x="156" y="206" text-anchor="end" font-size="10" fill="#aeb4ba">JSC</text>
+    <text x="662" y="199" font-size="13" font-weight="500" fill="#868e96">1.51×</text>
+    <circle cx="182.0" cy="195" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="2.4126551201460966s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.23s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="243.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="238" x2="174" y2="252" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="238" x2="650" y2="252" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="241" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Go</text>
+    <text x="156" y="256" text-anchor="end" font-size="10" fill="#aeb4ba">gc</text>
+    <text x="662" y="249" font-size="13" font-weight="500" fill="#868e96">1.62×</text>
+    <circle cx="182.0" cy="245" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="2.599256056991375s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-1.64s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="293.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="288" x2="174" y2="302" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="288" x2="650" y2="302" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="291" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">V8</text>
+    <text x="156" y="306" text-anchor="end" font-size="10" fill="#aeb4ba">Node</text>
+    <text x="662" y="299" font-size="13" font-weight="500" fill="#868e96">1.98×</text>
+    <circle cx="182.0" cy="295" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="3.161748945741268s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.05s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="343.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="338" x2="174" y2="352" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="338" x2="650" y2="352" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="341" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">AssemblyScript</text>
+    <text x="156" y="356" text-anchor="end" font-size="10" fill="#aeb4ba">asc -O3</text>
+    <text x="662" y="349" font-size="13" font-weight="500" fill="#868e96">2.02×</text>
+    <circle cx="182.0" cy="345" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="3.234040602137033s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.46s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="393.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="388" x2="174" y2="402" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="388" x2="650" y2="402" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="391" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">Porffor</text>
+    <text x="156" y="406" text-anchor="end" font-size="10" fill="#aeb4ba">runs 3 / 13</text>
+    <text x="662" y="399" font-size="13" font-weight="500" fill="#868e96">3.08×</text>
+    <circle cx="182.0" cy="395" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="4.926330541139543s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-2.87s"/>
+    </circle>
+  </g>
+  <g font-family="-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif">
+    <rect x="174" y="443.5" width="476" height="3" rx="1.5" fill="#edf0f2"/>
+    <line x1="174" y1="438" x2="174" y2="452" stroke="#ced4da" stroke-width="2"/>
+    <line x1="650" y1="438" x2="650" y2="452" stroke="#ced4da" stroke-width="2"/>
+    <text x="156" y="441" text-anchor="end" font-size="14" font-weight="500" fill="#343a40">NumPy</text>
+    <text x="156" y="456" text-anchor="end" font-size="10" fill="#aeb4ba">Python</text>
+    <text x="662" y="449" font-size="13" font-weight="500" fill="#868e96">8.31×</text>
+    <circle cx="182.0" cy="445" r="8" fill="#adb5bd">
+      <animate attributeName="cx" dur="10s" repeatCount="indefinite" calcMode="linear"
+        keyTimes="0;0.5;1" values="182.0;642.0;182.0" begin="-3.28s"/>
+    </circle>
+  </g>
+</svg>

package/cli.js

@@ -7,24 +7,27 @@
 import { readFileSync, writeFileSync } from 'fs'
 import { resolve } from 'path'
 import { pathToFileURL } from 'url'
-import { parse } from 'subscript/feature/jessie'
 import jz, { compile } from './index.js'
-import jzifyFn from './src/jzify.js'
-import { codegen } from './src/codegen.js'
+import transform from './transform.js'
 import { resolveModuleGraph } from './src/resolve.js'
 import { createRequire } from 'module'
 
 const jzRequire = createRequire(import.meta.url)
 const PKG = jzRequire('./package.json')
 
+function formatWarning(w) {
+  const where = w.line != null ? ` (${w.line}:${w.column})` : ''
+  return `warning[${w.code}]${where}: ${w.message}`
+}
+
 function showHelp() {
   console.log(`
 jz v${PKG.version} - min JS → WASM compiler
 
 Usage:
-  jz <file.js>              Compile JS to WASM (auto-jzify)
-  jz --strict <file.js>     Strict mode (no auto-transform)
-  jz --jzify <file.js>      Transform JS → jz (auto-derives output file)
+  jz <file.js>              Compile JS to WASM (full JS subset; .jz = strict)
+  jz --strict <file.js>     Strict mode — pure canonical subset, no lowering
+  jz --jzify <file.js>      Transform JS → jz source (auto-derives output file)
   jz -e <expression>        Evaluate expression
   jz --help                 Show this help
 
@@ -47,8 +50,8 @@ Options:
   --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)
+  --strict                  Pure canonical subset: reject full-JS syntax + dynamic fallbacks
+  --jzify                   Transform JS to jz source (no compilation)
   --eval, -e                Evaluate expression or file
   --wat                     Output WAT text instead of binary
   --resolve                 Resolve bare specifiers via Node.js module resolution
@@ -84,18 +87,20 @@ async function main() {
 
 async function handleEvaluate(args) {
   const input = args.join(' ')
-  let code
-
-  if (args.length === 1 && (args[0].endsWith('.js') || args[0].endsWith('.jz')))
-    code = readFileSync(args[0], 'utf8')
-  else
-    code = `export let _ = () => ${input}`
+  const isFile = args.length === 1 && (args[0].endsWith('.js') || args[0].endsWith('.jz'))
+  // A bare expression ("1 + 2") is wrapped in an arrow so its value can be printed. A file, or
+  // `-e` text that is already module-level (top-level export/import), compiles as-is — wrapping it
+  // would splice `export let _ = () => export …` and crash with a garbled SyntaxError.
+  const isModule = isFile || /^\s*(export|import)\b/m.test(input)
+  const code = isFile ? readFileSync(args[0], 'utf8')
+    : isModule ? input
+    : `export let _ = () => ${input}`
 
   const { exports } = jz(code)
 
-  // If there's an exported _ (expression eval), call it
-  if (exports._) console.log(exports._())
-  else console.log(exports)
+  if (exports._ !== undefined) console.log(exports._())                    // expression eval → print value
+  else if (typeof exports.main === 'function') console.log(exports.main()) // module with a main() entry
+  else console.log(`compiled; exports: ${Object.keys(exports).join(', ') || '(none)'}`)
 }
 
 async function handleJzify(args) {
@@ -107,9 +112,7 @@ 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 ast = parse(code)
-  const transformed = jzifyFn(ast)
-  const out = codegen(transformed) + '\n'
+  const out = transform(code) + '\n'
   if (outputFile === '-') {
     process.stdout.write(out)
   } else {
@@ -154,17 +157,19 @@ async function handleCompile(args) {
   const { code: codeRewritten, modules } = resolveModuleGraph(inputFile, { resolveNode })
   if (process.env.JZ_DEBUG_MODULES === '1') console.error('modules:', Object.keys(modules))
 
-  // .jz = strict (no auto-transform), .js = auto-jzify
-  // --strict forces strict for any extension
+  // jzify is default-on; strict (pure canonical subset) is opt-in.
+  // `.jz` files are treated as strict; `--strict` forces it for any extension.
+  if (inputFile.endsWith('.jz')) strict = true
+  const warnings = { entries: [] }
   const opts = {
     wat,
-    jzify: !strict && !inputFile.endsWith('.jz'),
+    warnings,
     strict,
     importMetaUrl: pathToFileURL(resolve(inputFile)).href,
     ...(optimize !== undefined && { optimize }),
     ...(host && { host }),
     ...(alloc === false && { alloc: false }),
-    ...(names && { profileNames: true }),
+    ...(names && { profile: { names: true } }),
     ...(Object.keys(modules).length && { modules }),
   }
 
@@ -175,6 +180,9 @@ async function handleCompile(args) {
 
   const result = compile(codeRewritten, opts)
 
+  for (const w of warnings.entries)
+    console.warn(formatWarning(w))
+
   if (outputFile === '-') {
     process.stdout.write(result)
   } else if (wat) {