@tishlang/tish 1.10.0 → 1.13.0

package/crates/tish_ui/src/runtime/mod.rs

@@ -2,14 +2,16 @@
 
 mod hooks;
 
-use std::cell::RefCell;
 use std::sync::Arc;
 
 pub use hooks::{
-    alloc_root_id, current_root_id, drop_host_for_root, install_host_for_root, native_create_root,
-    native_use_effect, native_use_memo, native_use_state, run_with_current_root, schedule_flush,
-    unregister_root, unregister_root_hooks_and_effects, with_host_for_root, HookState, RootId,
-    LEGACY_ROOT_ID,
+    alloc_root_id, current_root_id, drop_host_for_root, install_host_for_root,
+    install_thread_local_host, native_create_root,
+    native_use_effect, native_use_layout_effect, native_use_memo, native_use_ref,
+    native_use_state, run_with_current_root,
+    schedule_flush,
+    unregister_root, unregister_root_hooks_and_effects, with_host_for_root,
+    with_thread_local_host, HookState, RootId, LEGACY_ROOT_ID,
 };
 
 use tishlang_core::{ObjectMap, Value, VmRef};
@@ -157,27 +159,6 @@ impl Host for HeadlessHost {
     }
 }
 
-thread_local! {
-    static ACTIVE_HOST: RefCell<Option<Box<dyn Host>>> = RefCell::new(None);
-}
-
-/// Install the thread-local host used by [`schedule_flush`] / `createRoot`.
-pub fn install_thread_local_host(host: Box<dyn Host>) {
-    ACTIVE_HOST.with(|c| {
-        *c.borrow_mut() = Some(host);
-    });
-}
-
-pub fn with_thread_local_host<R>(f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
-    ACTIVE_HOST.with(|c| {
-        let mut opt = c.borrow_mut();
-        match opt.as_deref_mut() {
-            Some(host) => Some(f(host)),
-            None => None,
-        }
-    })
-}
-
 /// Tag registry hook for future host-specific intrinsic mapping (HTML tag → component kind).
 #[derive(Default)]
 pub struct TagRegistry;

package/crates/tish_vm/src/vm.rs

@@ -455,6 +455,46 @@ fn init_globals(enabled: &HashSet<String>) -> ObjectMap {
         "trunc".into(),
         Value::native(|args: &[Value]| math_builtins::trunc(args)),
     );
+    // Trig/hypot not covered by `math_builtins`; needed by the 3D engine's
+    // camera + character-controller math (atan2/hypot) on the wasm VM, where
+    // (unlike `--target js`) there is no host `Math` to fall through to.
+    math.insert(
+        "atan2".into(),
+        Value::native(|args: &[Value]| {
+            let y = args.first().and_then(|v| v.as_number()).unwrap_or(f64::NAN);
+            let x = args.get(1).and_then(|v| v.as_number()).unwrap_or(f64::NAN);
+            Value::Number(y.atan2(x))
+        }),
+    );
+    math.insert(
+        "atan".into(),
+        Value::native(|args: &[Value]| {
+            let n = args.first().and_then(|v| v.as_number()).unwrap_or(f64::NAN);
+            Value::Number(n.atan())
+        }),
+    );
+    math.insert(
+        "asin".into(),
+        Value::native(|args: &[Value]| {
+            let n = args.first().and_then(|v| v.as_number()).unwrap_or(f64::NAN);
+            Value::Number(n.asin())
+        }),
+    );
+    math.insert(
+        "acos".into(),
+        Value::native(|args: &[Value]| {
+            let n = args.first().and_then(|v| v.as_number()).unwrap_or(f64::NAN);
+            Value::Number(n.acos())
+        }),
+    );
+    math.insert(
+        "hypot".into(),
+        Value::native(|args: &[Value]| {
+            let nums: Vec<f64> = args.iter().filter_map(|v| v.as_number()).collect();
+            let sum_sq: f64 = nums.iter().map(|n| n * n).sum();
+            Value::Number(sum_sq.sqrt())
+        }),
+    );
     math.insert("PI".into(), Value::Number(std::f64::consts::PI));
     math.insert("E".into(), Value::Number(std::f64::consts::E));
     g.insert("Math".into(), value_object_from_map(math));

package/crates/tish_wasm/src/lib.rs

@@ -231,6 +231,33 @@ pub fn compile_to_wasm(
     emit_wasm_from_chunk(&chunk, output_path)
 }
 
+/// Compile a Tish project to a raw serialized bytecode chunk.
+///
+/// Writes a single `{output}` file of the exact bytes that the wasm/WASI runtime entry points
+/// (`start` / `run`) deserialize directly — the same chunk `--target wasm` embeds as base64 in
+/// its generated HTML loader, but written raw with no VM binary, JS glue, or HTML wrapper. Lets a
+/// host that already ships the VM runtime (e.g. a bundler) consume the bytecode without the
+/// throwaway standalone build.
+pub fn compile_to_bytecode(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    output_path: &Path,
+    optimize: bool,
+) -> Result<(), WasmError> {
+    let (chunk, _) = resolve_and_compile_to_chunk(entry_path, project_root, optimize)?;
+    let bytes = serialize(&chunk);
+    if let Some(parent) = output_path.parent().filter(|p| !p.as_os_str().is_empty()) {
+        std::fs::create_dir_all(parent).map_err(|e| WasmError {
+            message: format!("Cannot create output directory: {}", e),
+        })?;
+    }
+    std::fs::write(output_path, &bytes).map_err(|e| WasmError {
+        message: format!("Cannot write {}: {}", output_path.display(), e),
+    })?;
+    println!("Built: {} ({} bytes)", output_path.display(), bytes.len());
+    Ok(())
+}
+
 /// Compile a Tish project for Wasmtime/WASI.
 ///
 /// Produces a single `{output}.wasm` with embedded bytecode. Run with:

package/crates/tish_wasm_runtime/Cargo.toml

@@ -12,6 +12,10 @@ crate-type = ["cdylib", "rlib"]
 [features]
 # For wasm32-unknown-unknown (browser): wasm-bindgen, console output
 browser = ["dep:wasm-bindgen", "tishlang_vm/wasm"]
+# Browser WebGPU / JS-interop FFI + requestAnimationFrame render loop (the
+# `start(chunk, env)` entry). Reflection-based bridge over js-sys; no web-sys
+# WebGPU bindings needed since the WebGPU command API is synchronous.
+gpu = ["browser", "dep:js-sys"]
 # Built-in modules for WASI (wasm32-wasip1): align with `tishlang_cranelift_runtime` / CLI caps
 fs = ["tishlang_vm/fs"]
 process = ["tishlang_vm/process"]
@@ -24,7 +28,9 @@ ws = ["tishlang_vm/ws"]
 [dependencies]
 tishlang_bytecode = { path = "../tish_bytecode", version = ">=0.1" }
 tishlang_vm = { path = "../tish_vm", version = ">=0.1" }
+tishlang_core = { path = "../tish_core", version = ">=0.1" }
 wasm-bindgen = { version = "0.2", optional = true }
+js-sys = { version = "0.3", optional = true }
 
 # rand_core → getrandom 0.4 needs wasm_js on wasm32-unknown-unknown (browser VM build).
 [target.'cfg(target_arch = "wasm32")'.dependencies]

package/crates/tish_wasm_runtime/src/gpu.rs

@@ -0,0 +1,413 @@
+//! Browser WebGPU / JS-interop FFI for the tish bytecode VM.
+//!
+//! Lets a tish program compiled to wasm drive the browser's WebGPU (and any
+//! Web API) without hand-binding each call. The bridge is a tiny set of
+//! reflection-based primitives exposed as VM globals:
+//!
+//! - `js_global(name)` — read a JS global (e.g. `navigator`, `GPUBufferUsage`)
+//! - `js_get(handle, key)` / `js_set(handle, key, val)`
+//! - `js_call(handle, method, argsArray)` — call a method (the whole WebGPU
+//!   command API is synchronous, so this covers it)
+//! - `js_new(ctorNameOrHandle, argsArray)`
+//! - `js_typeof(handle)` — debugging
+//! - `f32a(arr)` / `u16a(arr)` / `u8a(arr)` — tish `number[]` → real typed array
+//! - `request_animation_frame(cb)` — drive a render loop
+//!
+//! GPU/JS objects (device, queue, context, buffers, pipelines, textures,
+//! ImageBitmaps, the host env object …) round-trip through the VM as opaque
+//! [`JsHandle`] values. Async startup (requestAdapter/requestDevice/fetch/
+//! createImageBitmap) is done in JS glue; the ready handles are handed to the
+//! VM via the `host` global by [`start`].
+
+use std::any::Any;
+use std::cell::{Cell, RefCell};
+use std::sync::Arc;
+
+use tishlang_bytecode::deserialize;
+use tishlang_core::{value_call, NativeFn, TishOpaque, Value};
+use tishlang_vm::Vm;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+// ---------------------------------------------------------------------------
+// Opaque JS handle
+// ---------------------------------------------------------------------------
+
+/// Opaque tish value wrapping a browser `JsValue`. `JsValue` is `!Send`, which
+/// is why `TishOpaque`'s `Send + Sync` bound is gated off in the browser
+/// (`!send-values`) build — see `tish_core/src/value.rs`.
+struct JsHandle(JsValue);
+
+impl TishOpaque for JsHandle {
+    fn type_name(&self) -> &'static str {
+        "JsHandle"
+    }
+    fn get_method(&self, _name: &str) -> Option<NativeFn> {
+        None
+    }
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}
+
+fn wrap(v: JsValue) -> Value {
+    Value::Opaque(Arc::new(JsHandle(v)))
+}
+
+fn unwrap_handle(v: &Value) -> Option<JsValue> {
+    match v {
+        Value::Opaque(o) => o.as_any().downcast_ref::<JsHandle>().map(|h| h.0.clone()),
+        _ => None,
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Marshalling  tish Value <-> JsValue
+// ---------------------------------------------------------------------------
+
+/// Convert a tish value to a JS value. Objects/arrays recurse; an opaque
+/// `JsHandle` is spliced in **by reference** (so descriptors can embed live GPU
+/// handles, e.g. `beginRenderPass({ colorAttachments:[{ view:<handle> }] })`).
+/// Functions/promises/symbols are not marshalled (return `null`).
+fn value_to_js(v: &Value) -> JsValue {
+    match v {
+        Value::Number(n) => JsValue::from_f64(*n),
+        Value::String(s) => JsValue::from_str(s.as_ref()),
+        Value::Bool(b) => JsValue::from_bool(*b),
+        Value::Null => JsValue::NULL,
+        Value::Opaque(o) => match o.as_any().downcast_ref::<JsHandle>() {
+            Some(h) => h.0.clone(),
+            None => JsValue::NULL,
+        },
+        Value::Array(arr) => {
+            let out = js_sys::Array::new();
+            for item in arr.borrow().iter() {
+                out.push(&value_to_js(item));
+            }
+            out.into()
+        }
+        Value::Object(obj) => {
+            let out = js_sys::Object::new();
+            let b = obj.borrow();
+            for (k, val) in b.strings.iter() {
+                let _ = js_sys::Reflect::set(
+                    &out,
+                    &JsValue::from_str(k.as_ref()),
+                    &value_to_js(val),
+                );
+            }
+            out.into()
+        }
+        _ => JsValue::NULL,
+    }
+}
+
+/// Convert a JS value back to tish. Primitives map directly; everything else
+/// (objects, functions, typed arrays, GPU objects) becomes an opaque handle —
+/// we deliberately do **not** expand JS containers into tish arrays/objects
+/// (that would re-introduce boxing and lose typed-array identity).
+fn js_to_value(v: JsValue) -> Value {
+    if v.is_null() || v.is_undefined() {
+        Value::Null
+    } else if let Some(n) = v.as_f64() {
+        Value::Number(n)
+    } else if let Some(b) = v.as_bool() {
+        Value::Bool(b)
+    } else if let Some(s) = v.as_string() {
+        Value::String(s.into())
+    } else {
+        wrap(v)
+    }
+}
+
+// ---------------------------------------------------------------------------
+// FFI builtins
+// ---------------------------------------------------------------------------
+
+fn ffi_js_global() -> Value {
+    Value::native(|args: &[Value]| {
+        let name = match args.first() {
+            Some(Value::String(s)) => s.clone(),
+            _ => return Value::Null,
+        };
+        match js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str(name.as_ref())) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_get() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let key = args.get(1).map(value_to_js).unwrap_or(JsValue::NULL);
+        match js_sys::Reflect::get(&obj, &key) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_set() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let key = args.get(1).map(value_to_js).unwrap_or(JsValue::NULL);
+        let val = args.get(2).map(value_to_js).unwrap_or(JsValue::NULL);
+        let _ = js_sys::Reflect::set(&obj, &key, &val);
+        Value::Null
+    })
+}
+
+fn ffi_js_call() -> Value {
+    Value::native(|args: &[Value]| {
+        let obj = match args.first().and_then(unwrap_handle) {
+            Some(o) => o,
+            None => return Value::Null,
+        };
+        let method = match args.get(1) {
+            Some(Value::String(s)) => s.clone(),
+            _ => return Value::Null,
+        };
+        let func = match js_sys::Reflect::get(&obj, &JsValue::from_str(method.as_ref())) {
+            Ok(f) => match f.dyn_into::<js_sys::Function>() {
+                Ok(f) => f,
+                Err(_) => return Value::Null,
+            },
+            Err(_) => return Value::Null,
+        };
+        let js_args = js_sys::Array::new();
+        if let Some(Value::Array(a)) = args.get(2) {
+            for item in a.borrow().iter() {
+                js_args.push(&value_to_js(item));
+            }
+        }
+        match js_sys::Reflect::apply(&func, &obj, &js_args) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_new() -> Value {
+    Value::native(|args: &[Value]| {
+        let ctor: JsValue = match args.first() {
+            Some(Value::String(s)) => {
+                match js_sys::Reflect::get(&js_sys::global(), &JsValue::from_str(s.as_ref())) {
+                    Ok(v) => v,
+                    Err(_) => return Value::Null,
+                }
+            }
+            Some(v @ Value::Opaque(_)) => match unwrap_handle(v) {
+                Some(h) => h,
+                None => return Value::Null,
+            },
+            _ => return Value::Null,
+        };
+        let ctor_fn = match ctor.dyn_into::<js_sys::Function>() {
+            Ok(f) => f,
+            Err(_) => return Value::Null,
+        };
+        let js_args = js_sys::Array::new();
+        if let Some(Value::Array(a)) = args.get(1) {
+            for item in a.borrow().iter() {
+                js_args.push(&value_to_js(item));
+            }
+        }
+        match js_sys::Reflect::construct(&ctor_fn, &js_args) {
+            Ok(v) => js_to_value(v),
+            Err(_) => Value::Null,
+        }
+    })
+}
+
+fn ffi_js_typeof() -> Value {
+    Value::native(|args: &[Value]| {
+        let v = args.first().map(value_to_js).unwrap_or(JsValue::NULL);
+        match v.js_typeof().as_string() {
+            Some(s) => Value::String(s.into()),
+            None => Value::Null,
+        }
+    })
+}
+
+/// `f32a(numberArray)` -> opaque `Float32Array` handle (one-shot copy). Use for
+/// per-frame uniform/transform staging. Large static buffers should instead be
+/// materialised host-side and passed in opaque (never boxed into a tish array).
+fn ffi_f32a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Float32Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as f32);
+        }
+        wrap(ta.into())
+    })
+}
+
+fn ffi_u16a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint16Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u16);
+        }
+        wrap(ta.into())
+    })
+}
+
+fn ffi_u8a() -> Value {
+    Value::native(|args: &[Value]| {
+        let arr = match args.first() {
+            Some(Value::Array(a)) => a.clone(),
+            _ => return Value::Null,
+        };
+        let b = arr.borrow();
+        let ta = js_sys::Uint8Array::new_with_length(b.len() as u32);
+        for (i, v) in b.iter().enumerate() {
+            ta.set_index(i as u32, v.as_number().unwrap_or(0.0) as u8);
+        }
+        wrap(ta.into())
+    })
+}
+
+// ---------------------------------------------------------------------------
+// requestAnimationFrame render loop
+// ---------------------------------------------------------------------------
+
+thread_local! {
+    static RAF_CALLBACK: RefCell<Option<Value>> = const { RefCell::new(None) };
+    static RAF_CLOSURE: RefCell<Option<Closure<dyn FnMut(f64)>>> = const { RefCell::new(None) };
+    // True while a frame is pending, so repeated request_animation_frame calls
+    // within one frame don't compound into runaway scheduling.
+    static RAF_SCHEDULED: Cell<bool> = const { Cell::new(false) };
+}
+
+/// Browser-driven per-frame entry: invoke the stored tish callback, then
+/// re-arm for the next frame. We re-schedule from Rust (rather than requiring
+/// the tish callback to call `request_animation_frame` again each frame) so the
+/// loop runs continuously as long as a callback is registered. `cancel`-ing the
+/// loop = clearing `RAF_CALLBACK`. The `value_call` runs the frame closure to
+/// completion; all WebGPU recording happens synchronously inside.
+fn tick(ts: f64) {
+    let cb = RAF_CALLBACK.with(|c| c.borrow().clone());
+    // This frame's pending schedule is now consumed.
+    RAF_SCHEDULED.with(|f| f.set(false));
+    if let Some(cb) = cb {
+        if matches!(cb, Value::Function(_)) {
+            value_call(&cb, &[Value::Number(ts)]);
+        }
+        // Re-arm only if the callback is still registered (allows a future
+        // cancel by clearing RAF_CALLBACK).
+        if RAF_CALLBACK.with(|c| c.borrow().is_some()) {
+            schedule_raf();
+        }
+    }
+}
+
+fn schedule_raf() {
+    // Coalesce: at most one rAF in flight at a time.
+    if RAF_SCHEDULED.with(|f| f.get()) {
+        return;
+    }
+    RAF_SCHEDULED.with(|f| f.set(true));
+    RAF_CLOSURE.with(|slot| {
+        let mut s = slot.borrow_mut();
+        if s.is_none() {
+            *s = Some(Closure::wrap(Box::new(|ts: f64| tick(ts)) as Box<dyn FnMut(f64)>));
+        }
+        let g = js_sys::global();
+        if let Ok(raf) = js_sys::Reflect::get(&g, &JsValue::from_str("requestAnimationFrame")) {
+            if let Ok(raf_fn) = raf.dyn_into::<js_sys::Function>() {
+                let _ = raf_fn.call1(&g, s.as_ref().unwrap().as_ref().unchecked_ref());
+            }
+        }
+    });
+}
+
+fn ffi_request_animation_frame() -> Value {
+    Value::native(|args: &[Value]| {
+        if let Some(cb) = args.first() {
+            RAF_CALLBACK.with(|c| *c.borrow_mut() = Some(cb.clone()));
+        }
+        schedule_raf();
+        Value::Null
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Install + entry point
+// ---------------------------------------------------------------------------
+
+fn install_ffi(vm: &mut Vm) {
+    vm.set_global("js_global".into(), ffi_js_global());
+    vm.set_global("js_get".into(), ffi_js_get());
+    vm.set_global("js_set".into(), ffi_js_set());
+    vm.set_global("js_call".into(), ffi_js_call());
+    vm.set_global("js_new".into(), ffi_js_new());
+    vm.set_global("js_typeof".into(), ffi_js_typeof());
+    vm.set_global("f32a".into(), ffi_f32a());
+    vm.set_global("u16a".into(), ffi_u16a());
+    vm.set_global("u8a".into(), ffi_u8a());
+    vm.set_global("request_animation_frame".into(), ffi_request_animation_frame());
+}
+
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_namespace = console, js_name = error)]
+    fn console_error(s: &str);
+}
+
+fn set_panic_hook() {
+    use std::sync::Once;
+    static HOOK: Once = Once::new();
+    HOOK.call_once(|| {
+        std::panic::set_hook(Box::new(|info| {
+            console_error(&format!("tish wasm panic: {}", info));
+        }));
+    });
+}
+
+/// Browser entry: run a tish bytecode `chunk` with the JS-interop FFI installed
+/// and the host environment object (device/queue/context/format/canvas/assets,
+/// built by the page's async startup glue) exposed as the `host` global.
+///
+/// Returns after top-level tish runs; the `requestAnimationFrame` loop keeps
+/// the captured globals alive via the stored callback, so the VM state persists
+/// across frames even though this call returns.
+/// Invoke the registered frame callback exactly once, without re-scheduling.
+/// For driving frames deterministically from JS when `requestAnimationFrame` is
+/// throttled (e.g. a hidden/offscreen preview tab) — verification & debugging.
+#[wasm_bindgen]
+pub fn tick_once(ts: f64) {
+    let cb = RAF_CALLBACK.with(|c| c.borrow().clone());
+    if let Some(cb) = cb {
+        if matches!(cb, Value::Function(_)) {
+            value_call(&cb, &[Value::Number(ts)]);
+        }
+    }
+}
+
+#[wasm_bindgen]
+pub fn start(chunk: Vec<u8>, env: JsValue) -> Result<(), JsValue> {
+    set_panic_hook();
+    let chunk = deserialize(&chunk).map_err(|e| JsValue::from_str(&e))?;
+    let mut vm = Vm::new();
+    install_ffi(&mut vm);
+    vm.set_global("host".into(), wrap(env));
+    vm.run(&chunk).map_err(|e| JsValue::from_str(&e))?;
+    Ok(())
+}

package/crates/tish_wasm_runtime/src/lib.rs

@@ -8,6 +8,11 @@
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;
 
+/// Browser WebGPU / JS-interop FFI + requestAnimationFrame render loop.
+/// Adds the `start(chunk, env)` wasm-bindgen entry used by the engine.
+#[cfg(feature = "gpu")]
+pub mod gpu;
+
 /// Run serialized Tish bytecode (WASI/Wasmtime or native).
 ///
 /// `chunk` is the output of `tishlang_bytecode::serialize(chunk)`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.10.0",
+  "version": "1.13.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {