jz 0.5.1 → 0.7.0

package/transform.js

@@ -0,0 +1,21 @@
+/**
+ * jz/transform — full JS source → canonical jz source.
+ *
+ * Parses, lowers full-JS forms (var/function/class/switch/==/undefined/…) into the
+ * jz subset via jzify, and pretty-prints back to jz source. The compile path runs
+ * jzify on the AST directly (default-on); this is the standalone source→source tool
+ * for tooling and REPLs ("clean my JS to the subset", auto-transform on paste).
+ *
+ * @module jz/transform
+ */
+import { parse } from 'subscript/feature/jessie'
+import jzify from './jzify/index.js'
+import { codegen } from './src/wat/codegen.js'
+
+/**
+ * @param {string} code - full-JS source
+ * @returns {string} canonical jz source
+ */
+export default function transform(code) {
+  return codegen(jzify(parse(code)))
+}

package/wasi.js

@@ -1,9 +1,18 @@
 /**
- * WASI Preview 1 polyfill for jz modules.
+ * WASI shim for jz-emitted modules — NOT a general WASI Preview 1 runtime.
  *
- * Provides wasi_snapshot_preview1 imports for environments without native WASI.
- * The compiled .wasm uses standard WASI — runs natively on wasmtime/wasmer/deno.
- * This polyfill is only needed for browsers and plain Node.
+ * jz emits only the few `wasi_snapshot_preview1` imports its lowerings use:
+ * `fd_write` (console.log/error), `fd_read` (stdin), `clock_time_get`
+ * (Date.now/performance.now/timers), `random_get` (only with `{ randomSeed: true }`,
+ * to seed Math.random), plus no-op `proc_exit` / `environ_*` stubs. This shim
+ * implements exactly that set, so jz modules run in browsers and plain Node
+ * without native WASI. (The compiled `.wasm` uses standard WASI and runs on
+ * wasmtime/wasmer/deno natively — the shim is only for hosts that lack WASI.)
+ *
+ * It is deliberately NOT a complete Preview 1 polyfill: `args_get`,
+ * `fd_fdstat_get`, `fd_prestat_dir_name`, `poll_oneoff`, `path_*` etc. are absent
+ * because jz never emits them. To run an arbitrary (e.g. C-compiled) WASI program,
+ * use a real runtime — wasmtime/wasmer/deno or Node's `node:wasi`.
  *
  * @example
  *   import { instantiate } from 'jz/wasi'
@@ -19,6 +28,8 @@
  * @param {function} [opts.write] - Custom write: (fd, text) => void
  * @param {function} [opts.read] - Custom read: (fd, buf: Uint8Array) => bytesRead
  */
+const TEXT_DEC = new TextDecoder()  // reused across every fd_write (was per-iov alloc)
+
 export function wasi(opts = {}) {
   let mem = null
   const fallbackWrite = (fd, text) => {
@@ -52,7 +63,7 @@ export function wasi(opts = {}) {
         for (let i = 0; i < iovs_len; i++) {
           const ptr = dv.getUint32(iovs + i * 8, true)
           const len = dv.getUint32(iovs + i * 8 + 4, true)
-          write(fd, new TextDecoder().decode(new Uint8Array(mem.buffer, ptr, len)))
+          write(fd, TEXT_DEC.decode(new Uint8Array(mem.buffer, ptr, len)))
           written += len
         }
         dv.setUint32(nwritten, written, true)
@@ -66,6 +77,14 @@ export function wasi(opts = {}) {
         dv.setBigInt64(result_ptr, now, true)
         return 0
       },
+      // Present only for modules compiled with { randomSeed: true } — one read of
+      // OS entropy to seed Math.random. Prefers crypto; falls back to Math.random.
+      random_get(buf, buf_len) {
+        const bytes = new Uint8Array(mem.buffer, buf, buf_len)
+        if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(bytes)
+        else for (let i = 0; i < buf_len; i++) bytes[i] = (Math.random() * 256) | 0
+        return 0
+      },
       proc_exit() {},
       environ_sizes_get(count_ptr, size_ptr) {
         const dv = new DataView(mem.buffer)
@@ -79,6 +98,29 @@ export function wasi(opts = {}) {
   }
 }
 
+/**
+ * Drive a `host: 'wasi'` module's WASM timer queue from JS scheduling.
+ *
+ * The wasi timer lowering compiles `setTimeout`/`setInterval` into an in-wasm
+ * queue drained by the exported `__timer_tick` (returns ms until the next due
+ * callback, ≤0 when the queue is empty). A native runtime ticks it from its own
+ * event loop; in a JS host we poll via `setInterval`, stopping once the queue
+ * drains. No-op for modules without timers. (The `host: 'js'` build lowers to
+ * `env.setTimeout` instead — that path lives in interop.js, not here.)
+ *
+ * @param {WebAssembly.Instance} inst
+ */
+export const attachTimers = (inst) => {
+  if (!inst.exports.__timer_tick) return
+  const tick = inst.exports.__timer_tick
+  let hadTimers = false
+  const id = setInterval(() => {
+    const remaining = tick()
+    if (remaining > 0) hadTimers = true
+    if (hadTimers && remaining <= 0) clearInterval(id)
+  }, 1)
+}
+
 /**
  * Compile and instantiate a jz WASI module.
  * @param {BufferSource} wasm