jz 0.1.1 → 0.2.0

package/module/symbol.js

@@ -4,9 +4,10 @@
  * Type=0 (ATOM): aux=atomId, offset=0.
  *
  * Reserved atom IDs (0-15):
- *   0 = reserved
- *   1 = null/undefined (type=0, aux=1, offset=0 — the nullish NaN sentinel)
- *   2-15 = reserved
+ *   0     = reserved
+ *   1     = null      (NULL_NAN sentinel)
+ *   2     = undefined (UNDEF_NAN sentinel)
+ *   3-15  = reserved
  *
  * User symbols start at ID 16.
  * Symbol('name')     → unique atom per call site (compile-time)

package/module/timer.js

@@ -1,10 +1,19 @@
 /**
  * Timer module — setTimeout/setInterval/clearTimeout/clearInterval.
  *
- * Pure-WASM timer queue using WASI clock_time_get for deadlines.
- * Runs inline after __start — no JS host, no Rust runner needed.
+ * Two host-mode lowerings:
  *
- * Timer queue: heap-allocated array of entries in linear memory.
+ *   `host: 'js'` (default): emit `env.setTimeout(cb: f64, delay: f64, repeat: i32) -> f64`
+ *     and `env.clearTimeout(id: f64) -> f64`. The JS host (src/host.js) drives both
+ *     via global setTimeout/setInterval and calls back into wasm through the
+ *     exported `__invoke_closure(clos: i64) -> f64` trampoline. No queue, no
+ *     polling — the host's event loop does the scheduling.
+ *
+ *   `host: 'wasi'`: pure-WASM timer queue using WASI clock_time_get for
+ *     deadlines. Runs inline after __start (or via __timer_loop on wasmtime/
+ *     wasmer). No JS host needed.
+ *
+ * WASI queue layout: heap-allocated array of entries in linear memory.
  *   Each entry (40 bytes):
  *     [0]  id (i32)           — unique timer ID
  *     [4]  pad (i32)
@@ -17,14 +26,32 @@
  * @module timer
  */
 
-import { typed, asF64, UNDEF_NAN, MAX_CLOSURE_ARITY, temp } from '../src/ir.js'
+import { typed, asF64, asI64, UNDEF_NAN, MAX_CLOSURE_ARITY, temp, tempI64 } from '../src/ir.js'
 import { emit } from '../src/emit.js'
-import { inc, PTR } from '../src/ctx.js'
+import { inc, PTR, LAYOUT } from '../src/ctx.js'
 
 const MAX_TIMERS = 64
 const ENTRY_SIZE = 40
 
-export default (ctx) => {
+const addImportOnce = (ctx, mod, name, fn) => {
+  if (ctx.module.imports.some(i => i[1] === `"${mod}"` && i[2] === `"${name}"`)) return
+  ctx.module.imports.push(['import', `"${mod}"`, `"${name}"`, fn])
+}
+
+// Shared "fire a NaN-boxed closure with 0 args" trampoline. Funcref index lives
+// in upper 16 bits of the pointer payload; remaining $ftN slots get UNDEF_NAN.
+// Closure is also passed as $__env so captures resolve via env-load.
+// `exported` adds (export "__invoke_closure") so the JS host can call it.
+const invokeClosureFn = (exported) => `(func $__invoke_closure${exported ? ' (export "__invoke_closure")' : ''} (param $clos i64) (result f64)
+  (call_indirect (type \$ftN)
+    (f64.reinterpret_i64 (local.get $clos))
+    (i32.const 0)
+    ${Array.from({length: MAX_CLOSURE_ARITY}, () => `(f64.const nan:${UNDEF_NAN})`).join('\n    ')}
+    (i32.wrap_i64 (i64.and
+      (i64.shr_u (local.get $clos) (i64.const ${LAYOUT.AUX_SHIFT}))
+      (i64.const ${LAYOUT.AUX_MASK})))))`
+
+const setupWasi = (ctx) => {
   // Always include init + tick + loop when timer module loads (structural, not per-emitter)
   inc('__timer_init', '__timer_tick', '__timer_loop')
 
@@ -32,7 +59,7 @@ export default (ctx) => {
     __timer_init: ['__alloc'],
     __timer_add: ['__time_ns'],
     __timer_cancel: [],
-    __timer_dispatch: [],
+    __timer_dispatch: ['__invoke_closure'],
     __timer_tick: ['__time_ns', '__timer_dispatch'],
     __timer_loop: ['__time_ns', '__timer_dispatch'],
   })
@@ -41,12 +68,8 @@ export default (ctx) => {
   // call_indirect always matches the $ftN type (env, argc, a0..a7)
   ctx.closure.floor = MAX_CLOSURE_ARITY
 
-  // Import WASI clock_time_get if not already imported (console.js may have done it)
-  if (!ctx.module.imports.some(i => i[1] === '"wasi_snapshot_preview1"' && i[2] === '"clock_time_get"')) {
-    ctx.module.imports.push(
-      ['import', '"wasi_snapshot_preview1"', '"clock_time_get"',
-        ['func', '$__clock_time_get', ['param', 'i32'], ['param', 'i64'], ['param', 'i32'], ['result', 'i32']]])
-  }
+  addImportOnce(ctx, 'wasi_snapshot_preview1', 'clock_time_get',
+    ['func', '$__clock_time_get', ['param', 'i32'], ['param', 'i64'], ['param', 'i32'], ['result', 'i32']])
 
   // __time_ns() → i64 — current monotonic nanoseconds
   // Reuses address 0-7 for the i64 output (same as __time_ms in console.js)
@@ -63,9 +86,9 @@ export default (ctx) => {
     (global.set $__timer_queue (call $__alloc (i32.const ${MAX_TIMERS * ENTRY_SIZE})))
     (memory.fill (global.get $__timer_queue) (i32.const 0) (i32.const ${MAX_TIMERS * ENTRY_SIZE})))`
 
-  // __timer_add(closure_ptr: f64, delay_ms: f64, interval: i32) → f64 (timer ID)
+  // __timer_add(closure_ptr: i64, delay_ms: f64, interval: i32) → f64 (timer ID)
   // interval=0 → setTimeout, interval=1 → setInterval
-  ctx.core.stdlib['__timer_add'] = `(func $__timer_add (param $clos f64) (param $delay f64) (param $is_interval i32) (result f64)
+  ctx.core.stdlib['__timer_add'] = `(func $__timer_add (param $clos i64) (param $delay f64) (param $is_interval i32) (result f64)
     (local $id i32)
     (local $slot i32)
     (local $base i32)
@@ -97,7 +120,7 @@ export default (ctx) => {
     (i32.store (i32.add (local.get $base) (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})))
       (local.get $id))
     ;; closure_ptr @ offset+8
-    (f64.store (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 8)))
+    (i64.store (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 8)))
       (local.get $clos))
     ;; deadline_ns @ offset+16
     (i64.store (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 16)))
@@ -143,7 +166,7 @@ export default (ctx) => {
     (local $slot i32)
     (local $base i32)
     (local $dispatched i32)
-    (local $clos f64)
+    (local $clos i64)
     (local $interval f64)
     (local $id i32)
     (local.set $dispatched (i32.const 0))
@@ -160,7 +183,7 @@ export default (ctx) => {
                 (local.get $now))
             (then
               ;; Read closure and interval before potentially clearing
-              (local.set $clos (f64.load (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 8)))))
+              (local.set $clos (i64.load (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 8)))))
               (local.set $interval (f64.load (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 24)))))
               (local.set $id (i32.load (i32.add (local.get $base) (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})))))
               ;; Interval? Reschedule
@@ -173,15 +196,8 @@ export default (ctx) => {
                   ;; Timeout: mark dead
                   (i32.store (i32.add (local.get $base) (i32.add (i32.mul (local.get $slot) (i32.const ${ENTRY_SIZE})) (i32.const 32))) (i32.const 0))
                   (global.set $__timer_count (i32.sub (global.get $__timer_count) (i32.const 1)))))
-              ;; Invoke closure via call_indirect on $ftN
-              ;; (env f64, argc i32, a0..a7 f64) → f64
-              (drop (call_indirect (type \$ftN)
-                (local.get $clos)                        ;; env = closure pointer itself
-                (i32.const 0)                             ;; argc = 0
-                ${Array.from({length: MAX_CLOSURE_ARITY}, () => `(f64.const nan:${UNDEF_NAN})`).join('\n                ')}
-                (i32.wrap_i64 (i64.and
-                  (i64.shr_u (i64.reinterpret_f64 (local.get $clos)) (i64.const 32))
-                  (i64.const 0x7FFF)))))
+              ;; Fire closure with 0 args (shared trampoline)
+              (drop (call $__invoke_closure (local.get $clos)))
               (local.set $dispatched (i32.add (local.get $dispatched) (i32.const 1)))))))
       (local.set $slot (i32.add (local.get $slot) (i32.const 1)))
       (br $scan)))
@@ -213,6 +229,8 @@ export default (ctx) => {
       ;; Loop
       (br $poll))))`
 
+  ctx.core.stdlib['__invoke_closure'] = invokeClosureFn(false)
+
   // Register globals for timer state
   // $__timer_queue: i32 — base address of timer array
   // $__timer_next_id: i32 — next timer ID
@@ -224,18 +242,18 @@ export default (ctx) => {
   // Emitter: setTimeout(closure, delay) → timer_id
   ctx.core.emit['setTimeout'] = (closureExpr, delayExpr) => {
     inc('__timer_add')
-    const t = temp('tc')
+    const t = tempI64('tc')
     return typed(['block', ['result', 'f64'],
-      ['local.set', `$${t}`, asF64(emit(closureExpr))],
+      ['local.set', `$${t}`, asI64(emit(closureExpr))],
       ['call', '$__timer_add', ['local.get', `$${t}`], asF64(emit(delayExpr)), ['i32.const', 0]]], 'f64')
   }
 
   // Emitter: setInterval(closure, delay) → timer_id
   ctx.core.emit['setInterval'] = (closureExpr, delayExpr) => {
     inc('__timer_add')
-    const t = temp('tc')
+    const t = tempI64('tc')
     return typed(['block', ['result', 'f64'],
-      ['local.set', `$${t}`, asF64(emit(closureExpr))],
+      ['local.set', `$${t}`, asI64(emit(closureExpr))],
       ['call', '$__timer_add', ['local.get', `$${t}`], asF64(emit(delayExpr)), ['i32.const', 1]]], 'f64')
   }
 
@@ -251,3 +269,43 @@ export default (ctx) => {
     return typed(['call', '$__timer_cancel', asF64(emit(idExpr))], 'f64')
   }
 }
+
+const setupJsHost = (ctx) => {
+  // Timer callbacks are invoked through __invoke_closure, which always pads to
+  // MAX_CLOSURE_ARITY. Set the ABI floor before plan() resolves $ftN width.
+  ctx.closure.floor = MAX_CLOSURE_ARITY
+
+  // env.setTimeout's cb param is i64 (NaN-box bits) to dodge V8's f64 NaN
+  // canonicalization at the wasm→JS boundary (same reason as env.print —
+  // see module/console.js header). delay is a real numeric f64 (no NaN-box
+  // hazard), repeat is i32, return is the timer id (numeric int).
+  const needSetTimeout = () => addImportOnce(ctx, 'env', 'setTimeout',
+    ['func', '$__set_timeout', ['param', 'i64'], ['param', 'f64'], ['param', 'i32'], ['result', 'f64']])
+  const needClearTimeout = () => addImportOnce(ctx, 'env', 'clearTimeout',
+    ['func', '$__clear_timeout', ['param', 'f64'], ['result', 'f64']])
+
+  ctx.core.stdlib['__invoke_closure'] = invokeClosureFn(true)
+
+  const emitSet = (closureExpr, delayExpr, repeat) => {
+    needSetTimeout()
+    inc('__invoke_closure')
+    return typed(['call', '$__set_timeout',
+      ['i64.reinterpret_f64', asF64(emit(closureExpr))],
+      asF64(emit(delayExpr)),
+      ['i32.const', repeat]], 'f64')
+  }
+  ctx.core.emit['setTimeout'] = (c, d) => emitSet(c, d, 0)
+  ctx.core.emit['setInterval'] = (c, d) => emitSet(c, d, 1)
+
+  const emitClear = (idExpr) => {
+    needClearTimeout()
+    return typed(['call', '$__clear_timeout', asF64(emit(idExpr))], 'f64')
+  }
+  ctx.core.emit['clearTimeout'] = emitClear
+  ctx.core.emit['clearInterval'] = emitClear
+}
+
+export default (ctx) => {
+  if (ctx.transform.host === 'wasi') setupWasi(ctx)
+  else setupJsHost(ctx)
+}