jz 0.1.0 → 0.1.1

package/README.md

@@ -17,15 +17,17 @@ dist(3, 4) // 5
 
 ## Why?
 
-**Write plain JS, compile to WASM** – fast, portable and long-lasting. JZ distills the modern functional core – the "good parts" [Crockford](https://www.youtube.com/watch?v=_DKkVvOt6dk) – from legacy semantics, features overhead and perf quirks.
+**Write plain JS, compile to WASM** – fast, portable and long-lasting. JZ distills the modern functional core – the "good parts" [Crockford](https://www.youtube.com/watch?v=_DKkVvOt6dk) – from legacy semantics, specs evolution and perf quirks.
 
 * **Static** – 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.
 <!-- * **Realtime** — compiles faster than `eval`, useful for live-coding and REPL. -->
 
-Inspired by [porffor](https://github.com/CanadaHonk/porffor) and [piezo](https://github.com/dy/piezo).
-<!-- Used internally by: web-audio-api, color-space, audiojs -->
+**Used by**: [web-audio-api](https://github.com/audiojs/web-audio-api), [color-space](https://github.com/colorjs/color-space), [audiojs](https://github.com/colorjs/audiojs). Inspired by [porffor](https://github.com/CanadaHonk/porffor) and [piezo](https://github.com/dy/piezo).
+<!-- * [audio-filter](https://github.com/audiojs/audio-filter)
+* [digital-filter](https://github.com/audiojs/digital-filter)
+* [time-stretch](https://github.com/audiojs/time-stretch) -->
 
 | Good for                    | Not for                    |
 |-----------------------------|----------------------------|
@@ -78,7 +80,7 @@ flowchart TB
     subgraph JS[JS — not supported]
         subgraph JZify[JZ + jzify]
             subgraph JZ[JZ strict]
-                j1["let/const, arrows, default/rest params, flow, break/continue, try/catch, a[]/a()/a.b, operators, strings, booleans, numbers, std, memory, host"]:::plain
+                j1["let/const, arrows, default/rest params, flow, break/continue, try/catch/finally, a[]/a()/a.b, operators, strings, booleans, numbers, std, memory, host"]:::plain
             end
             z1["var, function, arguments, switch, new Foo(), ==, !=, instanceof"]:::plain
         end
@@ -94,17 +96,17 @@ flowchart TB
 
 ```
 ┌────────────────────────────────────────────────────────────────────────┐
-│ JZify                                                    test262: 68%  │
+│ JZify                                                                  │
 │   var  function  arguments  switch  new Foo()                          │
 │   ==  !=  instanceof  undefined                                        │
 │                                                                        │
 │ ┌────────────────────────────────────────────────────────────────────┐ │
-│ │ JZ                                                   test262: 54%  │ │
-│ │   let/const  =>  ...xs  destructuring  import/export               │ │
+│ │ JZ                                                                 │ │
+│ │   let/const  =>  ...xs  destructuring  import/export  `${}`        │ │
 │ │   if/else  for/while/do-while/of/in  break/continue                │ │
 │ │   try/catch/finally  throw                                         │ │
-│ │   operators  strings  booleans  numbers  arrays  objects  `${}`    │ │
-│ │   Math  Number  String  Array  Object  JSON  RegExp  Symbol  null  │ │
+│ │   operators  strings  booleans  numbers  arrays  objects  null     │ │
+│ │   Math  Number  String  Array  Object  JSON  RegExp  Symbol        │ │
 │ │   ArrayBuffer  DataView  TypedArray  Map  Set                      │ │
 │ │   console  setTimeout/setInterval  Date  performance               │ │
 │ └────────────────────────────────────────────────────────────────────┘ │
@@ -118,6 +120,24 @@ Not supported
 ```
 
 
+## Benchmark
+
+| | **jz** | [Node](https://nodejs.org/) | [AS](https://github.com/AssemblyScript/assemblyscript) | WAT | C | [Go](https://go.dev/) | [Rust](https://www.rust-lang.org/) |
+|---|---|---|---|---|---|---|---|
+| [**biquad**](bench/biquad/biquad.js) | **6.44 ms**<br>**3.4 kB** | 12.30 ms<br>3.2 kB | 9.04 ms<br>1.9 kB | 6.48 ms<br>767 B | 5.43 ms<br>32.7 kB | 9.03 ms<br>1.60 MB<br>fma | 5.33 ms<br>380.7 kB |
+| [**tokenizer**](bench/tokenizer/tokenizer.js) | **0.10 ms**<br>**1.6 kB** | 0.18 ms<br>1.4 kB | 0.08 ms<br>1.5 kB | — | 0.13 ms<br>32.9 kB | 0.07 ms<br>1.60 MB | 0.12 ms<br>380.7 kB |
+| [**mat4**](bench/mat4/mat4.js) | **4.00 ms**<br>**1.7 kB** | 11.64 ms<br>1.1 kB | 9.18 ms<br>1.5 kB | 7.99 ms<br>353 B | 2.62 ms<br>32.8 kB | 11.93 ms<br>1.60 MB | 0.80 ms<br>380.7 kB |
+| [**aos**](bench/aos/aos.js) | **1.50 ms**<br>**2.3 kB** | 1.81 ms<br>1.1 kB | 1.91 ms<br>2.2 kB | — | 1.22 ms<br>32.9 kB | 0.90 ms<br>1.60 MB | 1.20 ms<br>380.7 kB |
+| [**bitwise**](bench/bitwise/bitwise.js) | **4.93 ms**<br>**1.2 kB** | 5.31 ms<br>1005 B | 12.36 ms<br>1.5 kB | 4.96 ms<br>355 B | 1.31 ms<br>32.9 kB | 5.24 ms<br>1.60 MB | 1.30 ms<br>380.7 kB |
+| [**poly**](bench/poly/poly.js) | **1.13 ms**<br>**1.3 kB** | 2.31 ms<br>1014 B | 1.14 ms<br>1.3 kB | — | 0.52 ms<br>32.9 kB | 0.80 ms<br>1.60 MB | 0.52 ms<br>380.7 kB |
+| [**callback**](bench/callback/callback.js) | **0.01 ms**<br>**1.5 kB** | 1.03 ms<br>828 B | 1.48 ms<br>1.9 kB | — | 0.09 ms<br>32.9 kB | 0.20 ms<br>1.60 MB | 0.08 ms<br>380.7 kB |
+| [**json**](bench/json/json.js) | **0.20 ms**<br>**2.8 kB** | 0.38 ms<br>923 B | — | — | 0.02 ms<br>32.8 kB | 1.06 ms<br>1.97 MB | 0.03 ms<br>380.7 kB |
+| [**watr**](bench/watr/watr.js) | **1.82 ms**<br>**137.1 kB** | 1.50 ms<br>2.6 kB | — | — | — | — | — |
+
+_Numbers from `node bench/bench.mjs` on Apple Silicon, May 2026. `jz` uses host imports for benchmark timing/logging (measures wasm without WASI console/perf bloat). Raw-JS size is the entry file; jz size is the bundled wasm artifact. `fma` is the documented Go arm64 fused-multiply-add checksum class. See [benchmark](./bench/)._
+
+
+
 
 ## FAQ
 
@@ -139,9 +159,8 @@ memory.Array([1, 2, 3])              // → array pointer
 memory.Float64Array([1.0, 2.0])      // → typed array pointer
 memory.Int32Array([10, 20, 30])      // all typed array constructors available
 
-// ⚠ Objects: keys and order must match the jz source declaration.
+// Objects: keys and order must match the jz source declaration.
 // jz objects are fixed-layout schemas (like C structs), not dynamic key bags.
-// If the jz source declares `{ x, y }`, you must pass `{ x, y }` in that order.
 memory.Object({ x: 3, y: 4 })       // → object pointer
 
 // Strings/arrays inside objects are auto-wrapped to pointers:
@@ -205,47 +224,26 @@ jz`export let f = () => ${{label: 'origin', x: 0, y: 0}}.label.length`  // 6
 
 Functions are imported as host calls. Non-serializable values (host objects, class instances) fall back to post-instantiation getters automatically.
 
-### Does it support ES module imports?
+### Does it support imports?
 
-Yes — standard ES `import` syntax is bundled at compile-time into a single WASM.
+Yes — standard ES `import` syntax, bundled at compile-time into one WASM.
 
 ```js
+// modules: jz source bundled at compile time
 const { exports } = jz(
   'import { add } from "./math.jz"; export let f = (a, b) => add(a, b)',
   { modules: { './math.jz': 'export let add = (a, b) => a + b' } }
 )
-```
-
-Transitive imports work (main → math → utils → …). Circular imports error at compile time. Output is always one WASM binary — no runtime resolution.
-
-**CLI** resolves filesystem imports automatically.
-
-```sh
-jz main.jz -o main.wasm    # reads ./math.jz, ./utils.jz automatically
-```
 
-**Browser**: fetch sources yourself, pass via `{ modules }`. The compiler stays synchronous and pure — no I/O.
-
-```js
-// Transitive bundling — all merged into one WASM
-const { exports } = jz(mainSrc, { modules: {
-  './math.jz': 'import { sq } from "./utils.jz"; export let dist = (x, y) => (sq(x) + sq(y)) ** 0.5',
-  // Fetch sources yourself, pass them in
-  './utils.jz': await fetch('./util.jz').then(r => r.text())
-} })
-```
-
-### Can I call JS/host functions from jz?
-
-Yes — JS functions are wired at instantiation via the `imports` option:
-
-```js
+// imports: JS functions wired at instantiation
 const { exports } = jz(
   'import { log } from "host"; export let f = (x) => { log(x); return x }',
   { imports: { host: { log: console.log } } }
 )
 ```
 
+Transitive imports work (main → math → utils → …). Circular imports error at compile time. Output is always one WASM binary — no runtime resolution.
+
 You can also pass whole host environment objects — `Math`, `Date`, `window`, `console`, or any custom namespace object. jz extracts the functions it needs via `Object.getOwnPropertyNames`, so non-enumerable built-ins (like `Math.sin`) work automatically:
 
 ```js
@@ -268,6 +266,23 @@ const { exports } = jz(
 )
 ```
 
+**CLI** resolves filesystem imports automatically.
+
+```sh
+jz main.jz -o main.wasm    # reads ./math.jz, ./utils.jz automatically
+```
+
+**Browser**: fetch sources yourself, pass via `{ modules }`. The compiler stays synchronous and pure — no I/O.
+
+```js
+// Transitive bundling — all merged into one WASM
+const { exports } = jz(mainSrc, { modules: {
+  './math.jz': 'import { sq } from "./utils.jz"; export let dist = (x, y) => (sq(x) + sq(y)) ** 0.5',
+  // Fetch sources yourself, pass them in
+  './utils.jz': await fetch('./util.jz').then(r => r.text())
+} })
+```
+
 ### Can two modules share data?
 
 Yes — `jz.memory()` creates a shared memory that modules compile into. Schemas accumulate automatically, so objects created in one module are readable by another:
@@ -305,14 +320,23 @@ wasmer run program.wasm
 deno run program.wasm
 ```
 
-`console.log` compiles to WASI `fd_write` — works natively on wasmtime/wasmer/deno without polyfills.
+Pure numeric modules have no imports and instantiate with standard
+`WebAssembly.Module` / `WebAssembly.Instance`, which is the right shape for JS
+hosts such as EdgeJS. Compile once at startup or build time, then reuse the
+module; do not compile JZ source per request.
+
+`console.log` compiles to WASI `fd_write` by default — works natively on
+wasmtime/wasmer/deno without polyfills. In JS hosts, `jz()` auto-applies the
+small `jz/wasi` polyfill; pass `{ write(fd, text) { ... } }` to capture or route
+stdout/stderr without depending on `process.stdout`.
 
 
 ### What host features are supported?
 
 The compiled `.wasm` uses one import namespace:
 
-- `wasi_snapshot_preview1` — standard WASI Preview 1 calls. Run natively on wasmtime, wasmer, deno; for browsers/Node, jz ships a tiny polyfill (`jz/wasi`) auto-applied by the `jz()` runtime.
+- none — pure scalar/compute modules. Instantiate directly with standard WebAssembly APIs.
+- `wasi_snapshot_preview1` — standard WASI Preview 1 calls. Run natively on wasmtime, wasmer, deno; for browsers/Node/EdgeJS-like hosts, jz ships a tiny polyfill (`jz/wasi`) auto-applied by the `jz()` runtime.
 
 | JS API | Maps to | Notes |
 |--------|---------|-------|
@@ -323,21 +347,6 @@ The compiled `.wasm` uses one import namespace:
 | `setTimeout`, `clearTimeout` | WASM timer queue + `__timer_tick` | JS runtime drives tick via `setInterval`; wasmtime uses blocking `__timer_loop` |
 | `setInterval`, `clearInterval` | WASM timer queue + `__timer_tick` | Same — native WASM implementation, no host imports |
 
-### How do I add custom operators / extend the stdlib?
-
-jz's emitter table (`ctx.core.emit`) maps AST operators → WASM IR generators. Module files in `module/` register handlers on it. To add your own:
-
-```js
-import { emitter } from 'jz/src/compile.js'
-
-// Register a custom operator: my.double(x) → x * 2
-emitter['my.double'] = (x) => {
-  return ['f64.mul', ['f64.const', 2], x]
-}
-```
-
-The naming convention follows the AST path: `Math.sin` → `math.sin`, `arr.push` → `.push`, typed variants like `.f64:push`. See any file in `module/` for the full pattern — each exports a function that registers emitters and stdlib on `ctx`.
-
 ### Can I compile jz to C?
 
 Yes, via [wasm2c](https://github.com/WebAssembly/wabt/blob/main/wasm2c) or [w2c2](https://github.com/turbolent/w2c2):
@@ -349,23 +358,6 @@ cc program.c -o program
 ```
 
 
-## Benchmark
-
-| | **jz** | [Node](https://nodejs.org/) | [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/) | [Porffor](https://github.com/CanadaHonk/porffor) |
-|---|---|---|---|---|---|---|---|---|---|---|
-| [**biquad**](bench/biquad/biquad.js) | **6.44ms**<br>**3.4kB** | 12.30ms<br>3.2kB | 9.04ms<br>1.9kB | 6.48ms<br>767 B | 5.43ms | 9.03ms<br>fma | 5.09ms | 5.33ms | 3.15s | — |
-| [**tokenizer**](bench/tokenizer/tokenizer.js) | **0.10ms**<br>**1.6kB** | 0.18ms<br>1.4kB | 0.08ms<br>1.5kB | — | 0.13ms | 0.07ms | 0.12ms | 0.12ms | 5.21ms | 0.46ms<br>2.6kB |
-| [**mat4**](bench/mat4/mat4.js) | **4.00ms**<br>**1.7kB** | 11.64ms<br>1.1kB | 9.18ms<br>1.5kB | 7.99ms<br>353 B | 2.62ms | 11.93ms | 2.60ms | 0.80ms | 323.69ms | 87.65ms<br>2.3kB |
-| [**aos**](bench/aos/aos.js) | **1.50ms**<br>**2.3kB** | 1.81ms<br>1.1kB | 1.91ms<br>2.2kB | — | 1.22ms | 0.90ms | 0.99ms | 1.20ms | 2.23ms | — |
-| [**bitwise**](bench/bitwise/bitwise.js) | **4.93ms**<br>**1.2kB** | 5.31ms<br>1005 B | 12.36ms<br>1.5kB | 4.96ms<br>355 B | 1.31ms | 5.24ms | 4.26ms | 1.30ms | 14.89ms | — |
-| [**poly**](bench/poly/poly.js) | **1.13ms**<br>**1.3kB** | 2.31ms<br>1014 B | 1.14ms<br>1.3kB | — | 0.52ms | 0.80ms | — | 0.52ms | 0.60ms | — |
-| [**callback**](bench/callback/callback.js) | **0.01ms**<br>**1.5kB** | 1.03ms<br>828 B | 1.48ms<br>1.9kB | — | 0.09ms | 0.20ms | 0.01ms | 0.08ms | 1.84ms | — |
-| [**json**](bench/json/json.js) | **0.20ms**<br>**2.8kB** | 0.38ms<br>923 B | — | — | 0.02ms | 1.06ms | — | 0.03ms | 1.19ms | — |
-| [**watr**](bench/watr/watr.js) | **1.82ms**<br>**137.1kB** | 1.50ms<br>85.3kB | — | — | — | — | — | — | — | — |
-
-_Numbers from `node bench/bench.mjs` on Apple Silicon._
-
-
 ## Alternatives
 
 * [porffor](https://github.com/CanadaHonk/porffor) — ahead-of-time JS→WASM compiler targeting full TC39 semantics. Implements the spec progressively (test262). Where jz restricts the language for performance, porffor aims for completeness.

package/index.js

@@ -42,9 +42,11 @@ import { parse } from 'subscript/jessie'
 import { compile as watrCompile, print as watrPrint, optimize as watrOptimize } from "watr";
 import { ctx, reset } from './src/ctx.js'
 import prepare, { GLOBALS } from './src/prepare.js'
-import compile, { emitter } from './src/compile.js'
+import compile from './src/compile.js'
+import { emitter } from './src/emit.js'
 import { optimizeFunc, resolveOptimize } from './src/optimize.js'
 import jzify from './src/jzify.js'
+import { normalizeSource } from './src/source.js'
 import {
   memory as enhanceMemory, instantiate as instantiateRuntime,
 } from './src/host.js'
@@ -62,6 +64,25 @@ const importsMayReturnExternal = (imports) => {
   return false
 }
 
+const nowMs = () => globalThis.performance?.now ? globalThis.performance.now() : Date.now()
+
+const compileProfiler = (profile) => {
+  if (!profile) return null
+  profile.entries ||= []
+  profile.totals ||= {}
+  return {
+    time(name, fn) {
+      const start = nowMs()
+      try { return fn() }
+      finally {
+        const ms = nowMs() - start
+        profile.entries.push({ name, ms })
+        profile.totals[name] = (profile.totals[name] || 0) + ms
+      }
+    },
+  }
+}
+
 /**
  * jz — JS subset → WASM compiler.
  *
@@ -94,9 +115,14 @@ jz.memory = enhanceMemory
  *   - `3`: reserved for future aggressive passes (currently == 2).
  *   - `{ level?: 0|1|2|3, watr?: bool, hoistAddrBase?: bool, ... }`: per-pass
  *     overrides on top of the chosen level. See PASS_NAMES in src/optimize.js.
+ * @param {object} [opts.profile] - Optional mutable profile sink populated with
+ *   `entries` and `totals` for parse / jzify / prepare / compile / plan / watr phases.
  * @returns {Uint8Array|string}
  */
 jz.compile = (code, opts = {}) => {
+  const profiler = compileProfiler(opts.profile)
+  const time = (name, fn) => profiler ? profiler.time(name, fn) : fn()
+
   reset(emitter, GLOBALS)
   ctx.error.src = code
 
@@ -125,21 +151,25 @@ jz.compile = (code, opts = {}) => {
     }
   }
 
-  let parsed = parse(code)
-  if (opts.jzify) parsed = jzify(parsed)
-  const ast = prepare(parsed)
-  const module = compile(ast)
+  let parsed = time('parse', () => parse(normalizeSource(code)))
+  if (opts.jzify) parsed = time('jzify', () => jzify(parsed))
+  const ast = time('prepare', () => prepare(parsed))
+  const module = time('compile', () => compile(ast, profiler))
 
   const cfg = ctx.transform.optimize
-  const optimized = cfg.watr ? watrOptimize(module) : module
+  const optimized = cfg.watr ? time('watrOptimize', () => watrOptimize(module)) : 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.
   // Only valuable to re-run when watr ran (watr is what re-introduces the boundaries).
   if (cfg.watr) {
-    for (const node of optimized) if (Array.isArray(node) && node[0] === 'func') optimizeFunc(node, cfg)
+    time('watrReopt', () => {
+      for (const node of optimized) if (Array.isArray(node) && node[0] === 'func') optimizeFunc(node, cfg)
+    })
   }
-  return opts.wat ? watrPrint(optimized) : watrCompile(optimized)
+  return opts.wat
+    ? time('watrPrint', () => watrPrint(optimized))
+    : time('watrCompile', () => watrCompile(optimized))
 }
 
 /**

package/module/array.js

@@ -8,8 +8,11 @@
  * @module array
  */
 
-import { emit, typed, asF64, asI32, valTypeOf, lookupValType, VAL, NULL_NAN, UNDEF_NAN, temp, tempI32, allocPtr, extractParams, multiCount, materializeMulti, arrayLoop, elemLoad, elemStore, truthyIR, extractF64Bits, appendStaticSlots, mkPtrIR, slotAddr, updateRep } from '../src/compile.js'
+import { typed, asF64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, allocPtr, multiCount, arrayLoop, elemLoad, elemStore, truthyIR, extractF64Bits, appendStaticSlots, mkPtrIR, slotAddr } from '../src/ir.js'
+import { emit, materializeMulti } from '../src/emit.js'
+import { valTypeOf, lookupValType, VAL, extractParams, updateRep } from '../src/analyze.js'
 import { ctx, inc, err, PTR } from '../src/ctx.js'
+import { staticPropertyKey } from '../src/key.js'
 import { strHashLiteral } from './collection.js'
 
 
@@ -466,7 +469,9 @@ export default (ctx) => {
       if (r) return r
     }
     // Literal string key on schema-known object → direct payload slot read (skip __dyn_get)
-    const litKey = Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string' ? idx[1] : null
+    const litKey = Array.isArray(idx) && idx[0] === 'str' && typeof idx[1] === 'string' ? idx[1]
+      : typeof arr === 'string' && lookupValType(arr) === VAL.OBJECT ? staticPropertyKey(idx)
+      : null
     if (litKey != null && typeof arr === 'string' && ctx.schema.find) {
       const slot = ctx.schema.find(arr, litKey)
       if (slot >= 0) {

package/module/collection.js

@@ -8,7 +8,9 @@
  * @module collection
  */
 
-import { emit, emitFlat, typed, asF64, asI32, valTypeOf, lookupValType, VAL, NULL_NAN, UNDEF_NAN, temp, tempI32, allocPtr } from '../src/compile.js'
+import { typed, asF64, asI32, NULL_NAN, UNDEF_NAN, temp, tempI32, allocPtr } from '../src/ir.js'
+import { emit, emitFlat } from '../src/emit.js'
+import { valTypeOf, lookupValType, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
 const SET_ENTRY = 16  // hash + key

package/module/console.js

@@ -12,7 +12,9 @@
  * @module wasi
  */
 
-import { emit, typed, asF64, valTypeOf, VAL } from '../src/compile.js'
+import { typed, asF64 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, VAL } from '../src/analyze.js'
 import { exprType } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 

package/module/core.js

@@ -9,7 +9,9 @@
  * @module core
  */
 
-import { emit, typed, asF64, asI32, valTypeOf, lookupValType, VAL, T, NULL_NAN, UNDEF_NAN, temp, usesDynProps, ptrOffsetIR, isNullish, repOf, updateRep } from '../src/compile.js'
+import { typed, asF64, asI32, NULL_NAN, UNDEF_NAN, temp, usesDynProps, ptrOffsetIR, isNullish } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, lookupValType, VAL, T, repOf, updateRep } from '../src/analyze.js'
 import { err, inc, PTR } from '../src/ctx.js'
 import { initSchema } from './schema.js'
 import { strHashLiteral } from './collection.js'

package/module/function.js

@@ -10,13 +10,14 @@
  * @module fn
  */
 
-import { emit, typed, asF64, asI32, T, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN, lookupValType, repOf } from '../src/compile.js'
-import { isReassigned } from '../src/emit.js'
+import { typed, asF64, asI32, mkPtrIR, temp, tempI32, MAX_CLOSURE_ARITY, UNDEF_NAN } from '../src/ir.js'
+import { emit, isReassigned } from '../src/emit.js'
+import { T, lookupValType, repOf } from '../src/analyze.js'
 import { PTR, inc, err } from '../src/ctx.js'
 
 
 export default (ctx) => {
-  inc('__mkptr', '__alloc', '__len', '__ptr_offset')
+  inc('__mkptr', '__alloc', '__len', '__ptr_offset', '__ptr_type')
 
   // Uniform closure convention: (env f64, argc i32, a0..a{MAX-1} f64) → f64
   if (!ctx.closure.types) ctx.closure.types = new Set()

package/module/json.js

@@ -8,7 +8,9 @@
  * @module json
  */
 
-import { emit, typed, asF64, T, temp, nullExpr, allocPtr, slotAddr } from '../src/compile.js'
+import { typed, asF64, temp, nullExpr, allocPtr, slotAddr } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { T } from '../src/analyze.js'
 import { err, inc, PTR } from '../src/ctx.js'
 import { strHashLiteral } from './collection.js'
 

package/module/math.js

@@ -13,7 +13,8 @@
  * @module math
  */
 
-import { emit, typed, asF64, asI32, temp, arrayLoop } from '../src/compile.js'
+import { typed, asF64, asI32, temp, arrayLoop } from '../src/ir.js'
+import { emit } from '../src/emit.js'
 import { inc } from '../src/ctx.js'
 import { repOf } from '../src/analyze.js'
 

package/module/number.js

@@ -9,7 +9,9 @@
  * @module number
  */
 
-import { emit, typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, valTypeOf, VAL, temp, tempI32, tempI64 } from '../src/compile.js'
+import { typed, asF64, asI32, asI64, NULL_NAN, UNDEF_NAN, temp, tempI32, tempI64 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
 export default (ctx) => {
@@ -557,12 +559,6 @@ export default (ctx) => {
           ['i32.const', 1]]]]], 'f64')
   }
 
-  ctx.core.emit['String'] = (x) => {
-    inc('__ftoa')
-    if (Array.isArray(x) && x[0] === 'str') return emit(x)
-    return typed(['call', '$__ftoa', asF64(emit(x)), ['i32.const', 0], ['i32.const', 0]], 'f64')
-  }
-
   // Number(x) — identity for numbers, i64→f64 conversion for BigInt
   ctx.core.emit['Number'] = (x) => {
     if (valTypeOf(x) === VAL.BIGINT)

package/module/object.js

@@ -7,7 +7,9 @@
  * @module object
  */
 
-import { emit, typed, asF64, valTypeOf, lookupValType, VAL, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr, repOf, updateRep } from '../src/compile.js'
+import { typed, asF64, temp, tempI32, allocPtr, needsDynShadow, mkPtrIR, extractF64Bits, appendStaticSlots, slotAddr } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, lookupValType, VAL, repOf, updateRep } from '../src/analyze.js'
 import { ctx, err, inc, PTR } from '../src/ctx.js'
 
 

package/module/regex.js

@@ -7,7 +7,8 @@
  * @module regex
  */
 
-import { emit, typed, asF64, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/compile.js'
+import { typed, asF64, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
 import { err, inc, PTR } from '../src/ctx.js'
 
 // Build IR that constructs a match array: [full, cap1, cap2, ...]

package/module/schema.js

@@ -7,7 +7,9 @@
  * @module schema
  */
 
-import { emit, typed, asF64, VAL, lookupValType, repOf } from '../src/compile.js'
+import { typed, asF64 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { VAL, lookupValType, repOf } from '../src/analyze.js'
 import { err, inc } from '../src/ctx.js'
 
 /** Initialize schema helpers on ctx. Called once per compilation from core module. */

package/module/string.js

@@ -10,7 +10,9 @@
  * @module string
  */
 
-import { emit, typed, asF64, asI32, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/compile.js'
+import { typed, asF64, asI32, NULL_NAN, UNDEF_NAN, mkPtrIR, temp, tempI32 } from '../src/ir.js'
+import { emit } from '../src/emit.js'
+import { valTypeOf, VAL } from '../src/analyze.js'
 import { inc, PTR } from '../src/ctx.js'
 
 
@@ -52,7 +54,8 @@ export default (ctx) => {
       for (let i = 0; i < str.length; i++) packed |= str.charCodeAt(i) << (i * 8)
       return mkPtrIR(PTR.SSO, str.length, packed)
     }
-    const len = str.length
+    const bytes = new TextEncoder().encode(str)
+    const len = bytes.length
     if (!ctx.memory.shared) {
       // Own memory: place in static data segment (no runtime allocation)
       if (!ctx.runtime.data) ctx.runtime.data = ''
@@ -61,7 +64,7 @@ export default (ctx) => {
       while (ctx.runtime.data.length % 4 !== 0) ctx.runtime.data += '\0'
       const offset = ctx.runtime.data.length
       ctx.runtime.data += String.fromCharCode(len & 0xFF, (len >> 8) & 0xFF, (len >> 16) & 0xFF, (len >> 24) & 0xFF)
-      for (let i = 0; i < len; i++) ctx.runtime.data += String.fromCharCode(str.charCodeAt(i))
+      for (let i = 0; i < len; i++) ctx.runtime.data += String.fromCharCode(bytes[i])
       ctx.runtime.dataDedup.set(str, offset)
       return mkPtrIR(PTR.STRING, 0, offset + 4)
     }
@@ -75,10 +78,10 @@ export default (ctx) => {
     }
     let off = ctx.runtime.strPoolDedup.get(str)
     if (off === undefined) {
-      // Pack length header then bytes; offset points PAST the length (at the data).
+      // Pack length header then UTF-8 bytes; offset points PAST the length (at the data).
       ctx.runtime.strPool += String.fromCharCode(len & 0xFF, (len >> 8) & 0xFF, (len >> 16) & 0xFF, (len >> 24) & 0xFF)
       off = ctx.runtime.strPool.length
-      ctx.runtime.strPool += str
+      for (let i = 0; i < len; i++) ctx.runtime.strPool += String.fromCharCode(bytes[i])
       ctx.runtime.strPoolDedup.set(str, off)
     }
     return mkPtrIR(PTR.STRING, 0, ['i32.add', ['global.get', '$__strBase'], ['i32.const', off]])
@@ -486,12 +489,19 @@ export default (ctx) => {
       (br $loop)))
     (call $__mkptr (i32.const ${PTR.STRING}) (i32.const 0) (local.get $off)))`
 
-  // Coerce value to string: numbers → __ftoa, plain NaN → "NaN", arrays → join(","), other pointers pass through
+  // Coerce value to string: numbers → __ftoa, nullish → static strings,
+  // plain NaN → "NaN", arrays → join(","), other string-like pointers pass through.
   ctx.core.stdlib['__to_str'] = `(func $__to_str (param $val f64) (result f64)
     (local $type i32)
+    (local $bits i64)
     ;; Not NaN → number, convert
     (if (f64.eq (local.get $val) (local.get $val))
       (then (return (call $__ftoa (local.get $val) (i32.const 0) (i32.const 0)))))
+    (local.set $bits (i64.reinterpret_f64 (local.get $val)))
+    (if (i64.eq (local.get $bits) (i64.const ${NULL_NAN}))
+      (then (return (call $__static_str (i32.const 5)))))
+    (if (i64.eq (local.get $bits) (i64.const ${UNDEF_NAN}))
+      (then (return (call $__static_str (i32.const 6)))))
     (local.set $type (call $__ptr_type (local.get $val)))
     ;; Plain NaN (type=0) → "NaN" string
     (if (i32.eqz (local.get $type))
@@ -774,6 +784,42 @@ export default (ctx) => {
     return result
   }
 
+  ctx.core.emit['strcat'] = (...parts) => {
+    inc('__to_str', '__str_byteLen', '__alloc', '__mkptr', '__str_copy')
+    if (!parts.length) return mkPtrIR(PTR.SSO, 0, 0)
+    if (parts.length === 1) return typed(['call', '$__to_str', asF64(emit(parts[0]))], 'f64')
+
+    const vals = parts.map(() => temp('s'))
+    const lens = parts.map(() => tempI32('sl'))
+    const total = tempI32('st')
+    const off = tempI32('so')
+    const dst = tempI32('sd')
+    const ir = []
+
+    for (let i = 0; i < parts.length; i++) {
+      ir.push(['local.set', `$${vals[i]}`, ['call', '$__to_str', asF64(emit(parts[i]))]])
+      ir.push(['local.set', `$${lens[i]}`, ['call', '$__str_byteLen', ['local.get', `$${vals[i]}`]]])
+    }
+    ir.push(['local.set', `$${total}`, ['i32.const', 0]])
+    for (const len of lens)
+      ir.push(['local.set', `$${total}`, ['i32.add', ['local.get', `$${total}`], ['local.get', `$${len}`]]])
+    const alloc = [
+      ['local.set', `$${off}`, ['call', '$__alloc', ['i32.add', ['i32.const', 4], ['local.get', `$${total}`]]]],
+      ['i32.store', ['local.get', `$${off}`], ['local.get', `$${total}`]],
+      ['local.set', `$${off}`, ['i32.add', ['local.get', `$${off}`], ['i32.const', 4]]],
+      ['local.set', `$${dst}`, ['local.get', `$${off}`]],
+    ]
+    for (let i = 0; i < parts.length; i++) {
+      alloc.push(['call', '$__str_copy', ['local.get', `$${vals[i]}`], ['local.get', `$${dst}`], ['local.get', `$${lens[i]}`]])
+      alloc.push(['local.set', `$${dst}`, ['i32.add', ['local.get', `$${dst}`], ['local.get', `$${lens[i]}`]]])
+    }
+    alloc.push(['call', '$__mkptr', ['i32.const', PTR.STRING], ['i32.const', 0], ['local.get', `$${off}`]])
+    ir.push(['if', ['result', 'f64'], ['i32.eqz', ['local.get', `$${total}`]],
+      ['then', mkPtrIR(PTR.SSO, 0, 0)],
+      ['else', ['block', ['result', 'f64'], ...alloc]]])
+    return typed(['block', ['result', 'f64'], ...ir], 'f64')
+  }
+
   ctx.core.emit['.padStart'] = (str, len, pad) => {
     inc('__str_pad')
     const vpad = pad != null ? asF64(emit(pad)) : mkPtrIR(PTR.SSO, 1, 32)
@@ -806,6 +852,17 @@ export default (ctx) => {
   }
 
   // String.fromCharCode(code) → 1-char SSO string
+  ctx.core.emit['String'] = (value) => {
+    if (value === undefined) return emit(['str', ''])
+    if (valTypeOf(value) === VAL.STRING) return emit(value)
+    if (valTypeOf(value) === VAL.NUMBER) {
+      inc('__ftoa')
+      return typed(['call', '$__ftoa', asF64(emit(value)), ['i32.const', 0], ['i32.const', 0]], 'f64')
+    }
+    inc('__to_str')
+    return typed(['call', '$__to_str', asF64(emit(value))], 'f64')
+  }
+
   ctx.core.emit['String.fromCharCode'] = (code) => mkPtrIR(PTR.SSO, 1, asI32(emit(code)))
 
   // String.fromCodePoint(cp) → UTF-8 encoded string

package/module/symbol.js

@@ -17,7 +17,8 @@
  * @module symbol
  */
 
-import { emit, typed, asF64, mkPtrIR } from '../src/compile.js'
+import { typed, asF64, mkPtrIR } from '../src/ir.js'
+import { emit } from '../src/emit.js'
 import { err, inc, PTR } from '../src/ctx.js'
 
 const RESERVED = 16  // first user atom ID

package/module/timer.js

@@ -17,9 +17,9 @@
  * @module timer
  */
 
-import { emit, typed, asF64, UNDEF_NAN, MAX_CLOSURE_ARITY } from '../src/compile.js'
+import { typed, asF64, UNDEF_NAN, MAX_CLOSURE_ARITY, temp } from '../src/ir.js'
+import { emit } from '../src/emit.js'
 import { inc, PTR } from '../src/ctx.js'
-import { temp } from '../src/ir.js'
 
 const MAX_TIMERS = 64
 const ENTRY_SIZE = 40