jz 0.5.1 → 0.7.0

package/package.json

@@ -1,37 +1,64 @@
 {
   "name": "jz",
-  "version": "0.5.1",
-  "description": "Functional JS subset compiling to WASM",
+  "version": "0.7.0",
+  "description": "Ahead-of-time compiler for the numeric core of JavaScript (DSP, audio, math, parsers) to lean GC-free WASM — valid jz is valid JS, no type annotations, no runtime.",
   "main": "index.js",
+  "types": "index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./wasi": "./wasi.js",
-    "./interop": "./interop.js"
+    "./interop": "./interop.js",
+    "./transform": "./transform.js"
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "cli.js",
     "wasi.js",
     "interop.js",
+    "layout.js",
+    "transform.js",
+    "jzify",
     "src",
     "module",
-    "README.md"
+    "dist/jz.js",
+    "dist/interop.js",
+    "README.md",
+    "jz.svg",
+    "alternatives.svg",
+    "bench/bench.svg"
   ],
   "bin": {
     "jz": "cli.js"
   },
   "scripts": {
     "test": "node test/index.js",
-    "test262": "node test/test262.js",
-    "test262:builtins": "node test/test262-builtins.js",
+    "test:opt0": "JZ_TEST_OPTIMIZE=0 node test/index.js",
+    "test:opt1": "JZ_TEST_OPTIMIZE=1 node test/index.js",
+    "test:opt3": "JZ_TEST_OPTIMIZE=3 node test/index.js",
+    "test:wasi": "JZ_TEST_HOST=wasi node test/index.js",
+    "test:wasm": "JZ_TEST_TARGET=jz.wasm node test/index.js",
+    "test:matrix": "npm test && npm run test:opt0 && npm run test:opt3 && npm run test:wasi",
+    "test:bench": "node test/bench.js",
+    "test:fuzz": "node test/fuzz.js --count=5000",
+    "test:ratchet": "node test/perf-ratchet.js",
+    "test:self": "node test/selfhost.js",
+    "test:262": "node test/test262.js",
+    "test:262:builtins": "node test/test262-builtins.js",
+    "test:all": "npm run test:matrix && npm run test:262 && npm run test:262:builtins && npm run test:bench && npm run test:self",
     "bench": "node bench/bench.mjs",
+    "bench:fuzz": "node scripts/fuzz-bench.mjs",
     "bench:size": "node scripts/bench-size.mjs",
     "bench:compile": "node scripts/bench-compile.mjs",
-    "build:examples": "for dir in examples/*; do node \"$dir/build.mjs\"; done",
-    "test:bench": "node test/bench.js",
-    "test:all": "npm test && npm run test:bench",
-    "prepublishOnly": "npm run test:all"
+    "bench:startup": "node scripts/bench-startup.mjs",
+    "bench:readme": "node scripts/bench-readme.mjs",
+    "build": "node scripts/build-dist.mjs",
+    "build:examples": "node examples/build.mjs all",
+    "prepare": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -44,8 +71,8 @@
   "author": "Dmitry Iv",
   "license": "MIT",
   "dependencies": {
-    "subscript": "^10.4.15",
-    "watr": "^4.6.9"
+    "subscript": "^10.4.17",
+    "watr": "^4.6.10"
   },
   "keywords": [
     "javascript",
@@ -53,9 +80,26 @@
     "compiler",
     "functional",
     "minimal",
-    "wasm"
+    "wasm",
+    "aot",
+    "simd",
+    "wasi",
+    "wat",
+    "dsp",
+    "audio",
+    "creative-coding",
+    "assemblyscript",
+    "porffor",
+    "numeric",
+    "signal-processing",
+    "math",
+    "audio-worklet",
+    "js-to-wasm",
+    "performance"
   ],
   "devDependencies": {
+    "esbuild": "^0.28.0",
+    "sprae": "^13.3.8",
     "tst": "^9.4.0"
   }
 }

package/src/abi/index.js

@@ -1,21 +1,5 @@
 /**
- * src/abi — internal codegen carriers.
- *
- * The `abi/` directory hosts compiler-internal codegen modules — one file per
- * value type, each exporting every carrier (slot strategy) the compiler may
- * pick for that type. **No user surface.** `opts.host` is the only knob users
- * see; internal representation is analysis-driven and per-site.
- *
- * Today the narrower has not yet been wired to pick carriers per site, so
- * each type module's `default` export is used as the carrier for every site
- * of that type. `ctx.abi.<type>` resolves to that default; codegen reads
- * `ctx.abi.string.ops.byteLen(...)` etc. Per-site dispatch arrives by
- * exposing all carriers (`ctx.abi.string.sso`, `.jsstring`) and letting
- * `narrow.js` tag each binding with a carrier choice.
- *
- * No presets, no preset-name discriminant, no public ABI knob — carrier
- * choice is analysis-driven, not user-pickable. See `.work/todo.md`
- * "Boundary protocol and internal representation" for the policy.
+ * src/abi — internal codegen carriers + per-site dispatch.
  *
  * @module src/abi
  */
@@ -25,11 +9,43 @@ import sso, { jsstring } from './string.js'
 import tagged from './object.js'
 import taggedLinear, { structInline } from './array.js'
 
-/** The default carrier bundle — what `ctx.abi` resolves to. Identity-stable
- *  reference so codegen can compare without string keys. */
-export const DEFAULTS = Object.freeze({ number: nanboxF64, string: sso, object: tagged, array: taggedLinear })
+/** All carriers per value type — keyed by stable id for rep.carrier lookup. */
+export const CARRIERS = Object.freeze({
+  number: Object.freeze({ nanboxF64 }),
+  string: Object.freeze({ sso, jsstring }),
+  object: Object.freeze({ tagged }),
+  array: Object.freeze({ taggedLinear, structInline }),
+})
+
+const DEFAULT_ID = Object.freeze({
+  number: 'nanboxF64',
+  string: 'sso',
+  object: 'tagged',
+  array: 'taggedLinear',
+})
+
+/** Pick carrier bundle for `type` given optional binding rep hints. */
+export function resolveCarrier(type, rep) {
+  const table = CARRIERS[type]
+  if (!table) return null
+  const id = rep?.carrier ?? DEFAULT_ID[type]
+  return table[id] ?? table[DEFAULT_ID[type]]
+}
+
+/** Default carrier ops bundle — backward-compatible flat shape on ctx.abi. */
+export const DEFAULTS = Object.freeze({
+  number: nanboxF64,
+  string: sso,
+  object: tagged,
+  array: taggedLinear,
+})
+
+/** ctx.abi bundle: default carriers + resolve() + registry. All access is by
+ *  fixed key (`ctx.abi.object.ops`, `.string`, `.resolve`, …), so a plain
+ *  literal — the shape jz compiles directly — is equivalent to the former
+ *  null-proto `Object.assign` merge. */
+export function makeAbi() {
+  return { ...DEFAULTS, carriers: CARRIERS, resolve: resolveCarrier }
+}
 
-// Carrier re-exports — for tests and tools that want to reach a specific
-// carrier directly. Per-site narrowing will use these via `ctx.abi.<type>`
-// once the narrower exposes the full carrier dictionary.
 export { nanboxF64, sso, jsstring, tagged, taggedLinear, structInline }

package/src/abi/string.js

@@ -56,42 +56,12 @@
 // take. Kept as a one-liner so each op reads as a single `call`.
 const ssoI64 = (sF64) => ['i64.reinterpret_f64', sF64]
 
-// LAYOUT lives in `src/ctx.js`, which loads this module mid-bootstrap (line 10
-// of ctx.js, before LAYOUT itself is bound). ESM live bindings mean the import
-// resolves but the value is `undefined` until ctx.js finishes. All charCodeAt /
-// inline paths read these constants at *call* time (compile-time, after ctx is
-// fully initialized) — never at module top level — so this is safe.
-import { LAYOUT } from '../ctx.js'
+import { isReassigned } from '../ast.js'
+import { LAYOUT, oobNanIR, ssoBitI64Hex } from '../../layout.js'
 
-// Local copy of analyze.js#isReassigned — pulling the real one creates a load-
-// order cycle (abi/string ← ctx ← analyze ← ir ← ctx). Kept minimal: detects
-// any `=`/compound-assign/`++`/`--` of `name` anywhere in `body`. `let`/`const`
-// declarations are NOT reassignments (the param can't be redeclared anyway,
-// but a shadowing inner `let s = ...` shouldn't poison the outer param's
-// fast path). False positives are conservative — we just disable the fast
-// path and fall through to shape 2.
-const _CC_ASSIGN_OPS = new Set(['=', '+=', '-=', '*=', '/=', '%=', '&=', '|=', '^=', '>>=', '<<=', '>>>=', '||=', '&&=', '??='])
-const _paramReassigned = (body, name) => {
-  if (!Array.isArray(body)) return false
-  const op = body[0]
-  if (_CC_ASSIGN_OPS.has(op) && body[1] === name) return true
-  if ((op === '++' || op === '--') && body[1] === name) return true
-  if (op === 'let' || op === 'const') {
-    for (let i = 1; i < body.length; i++) {
-      const d = body[i]
-      if (Array.isArray(d) && d[0] === '=' && d[2] != null && _paramReassigned(d[2], name)) return true
-    }
-    return false
-  }
-  for (let i = 1; i < body.length; i++) if (_paramReassigned(body[i], name)) return true
-  return false
-}
-
-/** Pre-shifted SSO discriminator (bit 46 of the i64 ptr). Computed lazily on
- *  first read since LAYOUT is undefined when this module's top level runs.
- *  Memoized in the closure so all later call sites pay zero overhead. */
+/** Pre-shifted SSO discriminator — layout.js is cycle-free; memoized at first use. */
 let _ssoBitI64 = null
-const ssoBitI64 = () => _ssoBitI64 ??= '0x' + (BigInt(LAYOUT.SSO_BIT) << BigInt(LAYOUT.AUX_SHIFT)).toString(16).toUpperCase().padStart(16, '0')
+const ssoBitI64 = () => _ssoBitI64 ??= ssoBitI64Hex()
 
 /** Allocate a fresh i64 local in the current function. Replicated here (not
  *  imported from `src/ir.js`) to keep this module loadable during ctx.js
@@ -134,7 +104,7 @@ function emitDecompCharRead(dec, iI32, ctx, oobNan) {
     ['else', heapByteExpr]]
   const use = ['if', ['result', rt],
     ['i32.ge_u', idx, ['local.get', `$${dec.len}`]],
-    ['then', oobNan ? ['f64.const', 'nan:0x7FF8000000000000'] : ['i32.const', 0]],
+    ['then', oobNan ? oobNanIR() : ['i32.const', 0]],
     ['else', oobNan ? ['f64.convert_i32_u', ccByte] : ccByte]]
   return spill
     ? ['block', ['result', rt], ['local.set', `$${spill}`, iI32], use]
@@ -252,7 +222,7 @@ export const sso = {
       //     being false to terminate; an i32 `0` would loop forever.
       // A fresh OOB node per use — IR nodes must not be structurally shared
       // (later passes mutate in place).
-      const mkOob = () => oobNan ? ['f64.const', 'nan:0x7FF8000000000000'] : ['i32.const', 0]
+      const mkOob = () => oobNan ? oobNanIR() : ['i32.const', 0]
       const rt = oobNan ? 'f64' : 'i32'
       const widen = b => oobNan ? ['f64.convert_i32_u', b] : b
       // Shape 1: receiver is a `local.get` of a non-boxed function parameter.
@@ -273,7 +243,7 @@ export const sso = {
         // to actually be `f64` (i64.reinterpret_f64 below would fail
         // validation otherwise — narrowed-to-int params have type 'i32').
         if (param && param.type === 'f64' && param.ptrKind == null
-            && !isBoxed && ctx.func.body && !_paramReassigned(ctx.func.body, name)) {
+            && !isBoxed && ctx.func.body && !isReassigned(ctx.func.body, name)) {
           if (!ctx.func.charDecomp) ctx.func.charDecomp = new Map()
           let dec = ctx.func.charDecomp.get(name)
           if (!dec) {
@@ -362,10 +332,31 @@ export const sso = {
       return preface
     },
 
-    /** Content equality. Both args: f64 slot carriers. Returns i32 boolean. */
+    /** Content equality. Both args: f64 slot carriers. Returns i32 boolean.
+     *  The bit-eq fast path is inlined at the site: static-literal dedup, SSO
+     *  packing and slice interning make identical bits the DOMINANT equal case
+     *  (a compiler comparing tree tags against literals hits it ~always), so
+     *  most comparisons skip the __str_eq call entirely. Content compare only
+     *  on bit-mismatch. */
     eq: (aF64, bF64, ctx) => {
       ctx.core.includes.add('__str_eq')
-      return ['call', '$__str_eq', ssoI64(aF64), ssoI64(bF64)]
+      // i64 temps allocated through the passed ctx — importing ir.js's tempI64
+      // here would close the abi→ir→ctx→abi module cycle the kernel bundler
+      // rejects (mirrors freshLocal's registration).
+      const fresh = () => {
+        let n
+        do { n = `seq${ctx.func.uniq++}` } while (ctx.func.locals.has(n))
+        ctx.func.locals.set(n, 'i64')
+        return n
+      }
+      const ta = fresh(), tb = fresh()
+      return ['block', ['result', 'i32'],
+        ['local.set', `$${ta}`, ssoI64(aF64)],
+        ['local.set', `$${tb}`, ssoI64(bF64)],
+        ['if', ['result', 'i32'],
+          ['i64.eq', ['local.get', `$${ta}`], ['local.get', `$${tb}`]],
+          ['then', ['i32.const', 1]],
+          ['else', ['call', '$__str_eq', ['local.get', `$${ta}`], ['local.get', `$${tb}`]]]]]
     },
 
     /** Three-way byte compare. Both args: f64 slot carriers. Returns i32 ∈ {-1, 0, 1}. */
@@ -375,8 +366,14 @@ export const sso = {
     },
 
     /** Concat with ToString coercion on both sides. Both args: f64 slot
-     *  carriers. Returns f64 (the new STRING ptr's slot carrier). */
-    concat: (aF64, bF64, ctx) => {
+     *  carriers. Returns f64 (the new STRING ptr's slot carrier).
+     *  Named `cat`, not `concat`: under self-host this op is invoked as a
+     *  method on the statically-untyped `ctx.abi.string.ops` receiver, and the
+     *  name `concat` collides with `Array.prototype.concat` — the method-call
+     *  dispatcher's string/array runtime guess (emit.js) would hijack it into a
+     *  bogus array concat. A non-builtin name routes through dynamic property
+     *  dispatch (load the closure slot, call it) correctly. */
+    cat: (aF64, bF64, ctx) => {
       ctx.core.includes.add('__str_concat')
       return ['call', '$__str_concat', ssoI64(aF64), ssoI64(bF64)]
     },