@tishlang/tish 1.10.0 → 1.12.0

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

@@ -5,6 +5,8 @@ use std::cell::{Cell, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
+use std::sync::Arc;
+
 use tishlang_core::{ObjectMap, Value, VmRef};
 
 use super::Host;
@@ -18,9 +20,10 @@ pub const LEGACY_ROOT_ID: RootId = 1;
 thread_local! {
     static HOOKS: RefCell<HashMap<RootId, HookState>> = RefCell::new(HashMap::new());
     static CURRENT_ROOT: Cell<Option<RootId>> = Cell::new(None);
-    static HOSTS: RefCell<HashMap<RootId, Box<dyn Host>>> = RefCell::new(HashMap::new());
+    static HOSTS: RefCell<HashMap<RootId, Rc<RefCell<Box<dyn Host>>>>> = RefCell::new(HashMap::new());
     static NEXT_DYNAMIC_ROOT_ID: Cell<RootId> = Cell::new(2);
     static IN_FLUSH: Cell<bool> = Cell::new(false);
+    static IN_EFFECT_FLUSH: Cell<bool> = Cell::new(false);
 }
 
 /// Allocate an id for an additional in-process window (starts at 2; 1 is legacy primary).
@@ -42,7 +45,8 @@ fn ensure_hook_entry(root_id: RootId) {
 pub fn install_host_for_root(root_id: RootId, host: Box<dyn Host>) {
     ensure_hook_entry(root_id);
     HOSTS.with(|h| {
-        h.borrow_mut().insert(root_id, host);
+        h.borrow_mut()
+            .insert(root_id, Rc::new(RefCell::new(host)));
     });
 }
 
@@ -77,8 +81,10 @@ pub fn unregister_root(root_id: RootId) {
 
 pub fn with_host_for_root<R>(root_id: RootId, f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
     HOSTS.with(|c| {
-        let mut m = c.borrow_mut();
-        m.get_mut(&root_id).map(|host| f(host.as_mut()))
+        let m = c.borrow();
+        let host = m.get(&root_id)?;
+        let mut host = host.try_borrow_mut().ok()?;
+        Some(f(host.as_mut()))
     })
 }
 
@@ -128,6 +134,11 @@ pub struct HookState {
     effect_cells: Rc<RefCell<Vec<EffectCell>>>,
     effect_cursor: usize,
     pending_effects: Rc<RefCell<Vec<PendingEffect>>>,
+    layout_effect_cells: Rc<RefCell<Vec<EffectCell>>>,
+    layout_effect_cursor: usize,
+    pending_layout_effects: Rc<RefCell<Vec<PendingEffect>>>,
+    ref_slots: Rc<RefCell<Vec<Value>>>,
+    ref_cursor: usize,
 }
 
 impl Default for HookState {
@@ -143,6 +154,11 @@ impl Default for HookState {
             effect_cells: Rc::new(RefCell::new(Vec::new())),
             effect_cursor: 0,
             pending_effects: Rc::new(RefCell::new(Vec::new())),
+            layout_effect_cells: Rc::new(RefCell::new(Vec::new())),
+            layout_effect_cursor: 0,
+            pending_layout_effects: Rc::new(RefCell::new(Vec::new())),
+            ref_slots: Rc::new(RefCell::new(Vec::new())),
+            ref_cursor: 0,
         }
     }
 }
@@ -160,11 +176,17 @@ fn run_all_effect_cleanups(cells: &RefCell<Vec<EffectCell>>) {
 impl HookState {
     pub fn reset_for_new_root(&mut self) {
         run_all_effect_cleanups(self.effect_cells.as_ref());
+        run_all_effect_cleanups(self.layout_effect_cells.as_ref());
         self.effect_cells.borrow_mut().clear();
+        self.layout_effect_cells.borrow_mut().clear();
         self.effect_cursor = 0;
+        self.layout_effect_cursor = 0;
         self.pending_effects.borrow_mut().clear();
+        self.pending_layout_effects.borrow_mut().clear();
         self.state_slots.borrow_mut().clear();
         self.cursor = 0;
+        self.ref_slots.borrow_mut().clear();
+        self.ref_cursor = 0;
         self.root_vnode = None;
         self.flush_scheduled = false;
         self.memo_cache.borrow_mut().clear();
@@ -191,6 +213,7 @@ fn memo_dep_eq(a: &Value, b: &Value) -> bool {
             }
             ab.iter().zip(bb.iter()).all(|(x, y)| memo_dep_eq(x, y))
         }
+        (Value::Object(a), Value::Object(b)) => tishlang_core::VmRef::ptr_eq(a, b),
         _ => false,
     }
 }
@@ -239,7 +262,7 @@ pub fn native_use_state(args: &[Value]) -> Value {
                     st.flush_scheduled = true;
                 }
             });
-            if !IN_FLUSH.get() {
+            if !IN_FLUSH.get() && !IN_EFFECT_FLUSH.get() {
                 drain_flush_queue();
             }
             Value::Null
@@ -284,9 +307,29 @@ pub fn native_use_memo(args: &[Value]) -> Value {
     })
 }
 
-/// `useEffect(effect, deps?)` — runs `effect` after the host commits the tree; compares `deps` like `useMemo`.
-/// If `effect` returns a function, it is called before the next run or on root teardown (`render` replacement / [`unregister_root`]).
-pub fn native_use_effect(args: &[Value]) -> Value {
+/// `useRef(initial)` → `{ current: initial }` (stable object identity per slot).
+pub fn native_use_ref(args: &[Value]) -> Value {
+    let initial = args.first().cloned().unwrap_or(Value::Null);
+    let root_id = root_id_for_hooks();
+    HOOKS.with(|h| {
+        let mut map = h.borrow_mut();
+        let st = map.entry(root_id).or_default();
+        let i = st.ref_cursor;
+        st.ref_cursor += 1;
+        while i >= st.ref_slots.borrow().len() {
+            let mut m = ObjectMap::default();
+            m.insert(Arc::from("current"), initial.clone());
+            st.ref_slots.borrow_mut().push(Value::object(m));
+        }
+        let out = st.ref_slots.borrow()[i].clone();
+        out
+    })
+}
+
+fn queue_effect(
+    args: &[Value],
+    layout: bool,
+) -> Value {
     let Some(Value::Function(effect_fn)) = args.first() else {
         return Value::Null;
     };
@@ -301,9 +344,22 @@ pub fn native_use_effect(args: &[Value]) -> Value {
     HOOKS.with(|h| {
         let mut map = h.borrow_mut();
         let st = map.entry(root_id).or_default();
-        let i = st.effect_cursor;
-        st.effect_cursor += 1;
-        let cells = &st.effect_cells.clone();
+        let (cursor, cells, pending) = if layout {
+            (
+                &mut st.layout_effect_cursor,
+                &st.layout_effect_cells,
+                &st.pending_layout_effects,
+            )
+        } else {
+            (
+                &mut st.effect_cursor,
+                &st.effect_cells,
+                &st.pending_effects,
+            )
+        };
+        let i = *cursor;
+        *cursor += 1;
+        let cells = cells.clone();
         let mut cells_b = cells.borrow_mut();
         while cells_b.len() <= i {
             cells_b.push(EffectCell::default());
@@ -315,7 +371,7 @@ pub fn native_use_effect(args: &[Value]) -> Value {
         drop(cells_b);
 
         if should_run {
-            st.pending_effects.borrow_mut().push(PendingEffect {
+            pending.borrow_mut().push(PendingEffect {
                 slot: i,
                 effect_fn: Value::Function(effect_fn),
                 new_deps: deps,
@@ -325,14 +381,29 @@ pub fn native_use_effect(args: &[Value]) -> Value {
     })
 }
 
-fn flush_pending_effects(root_id: RootId) {
+/// `useLayoutEffect(effect, deps?)` — runs synchronously after commit, before `useEffect`.
+pub fn native_use_layout_effect(args: &[Value]) -> Value {
+    queue_effect(args, true)
+}
+
+/// `useEffect(effect, deps?)` — runs `effect` after the host commits the tree; compares `deps` like `useMemo`.
+/// If `effect` returns a function, it is called before the next run or on root teardown (`render` replacement / [`unregister_root`]).
+pub fn native_use_effect(args: &[Value]) -> Value {
+    queue_effect(args, false)
+}
+
+fn flush_pending_effects_for(
+    root_id: RootId,
+    pending_key: impl FnOnce(&mut HookState) -> &Rc<RefCell<Vec<PendingEffect>>>,
+    cells_key: impl FnOnce(&HookState) -> Rc<RefCell<Vec<EffectCell>>>,
+) {
     let pending: Vec<PendingEffect> = HOOKS.with(|h| {
         h.borrow_mut()
             .get_mut(&root_id)
-            .map(|st| std::mem::take(&mut *st.pending_effects.borrow_mut()))
+            .map(|st| std::mem::take(&mut *pending_key(st).borrow_mut()))
             .unwrap_or_default()
     });
-    let cells_rc = HOOKS.with(|h| h.borrow().get(&root_id).map(|st| st.effect_cells.clone()));
+    let cells_rc = HOOKS.with(|h| h.borrow().get(&root_id).map(cells_key));
     let Some(cells_rc) = cells_rc else {
         return;
     };
@@ -370,6 +441,26 @@ fn flush_pending_effects(root_id: RootId) {
     }
 }
 
+fn flush_pending_layout_effects(root_id: RootId) {
+    IN_EFFECT_FLUSH.set(true);
+    flush_pending_effects_for(
+        root_id,
+        |st| &st.pending_layout_effects,
+        |st| st.layout_effect_cells.clone(),
+    );
+    IN_EFFECT_FLUSH.set(false);
+}
+
+fn flush_pending_effects(root_id: RootId) {
+    IN_EFFECT_FLUSH.set(true);
+    flush_pending_effects_for(
+        root_id,
+        |st| &st.pending_effects,
+        |st| st.effect_cells.clone(),
+    );
+    IN_EFFECT_FLUSH.set(false);
+}
+
 fn parse_root_id_arg(args: &[Value]) -> RootId {
     match args.first() {
         Some(Value::Number(n)) if n.is_finite() && *n >= 1.0 && n.fract() == 0.0 => *n as u64,
@@ -416,6 +507,10 @@ pub fn schedule_flush() {
 }
 
 fn drain_flush_queue() {
+    drain_flush_queue_on_current_thread();
+}
+
+fn drain_flush_queue_on_current_thread() {
     loop {
         let root_id = HOOKS.with(|h| {
             h.borrow()
@@ -440,8 +535,11 @@ fn drain_flush_queue() {
             let st = map.get_mut(&root_id)?;
             st.cursor = 0;
             st.memo_cursor = 0;
+            st.ref_cursor = 0;
             st.effect_cursor = 0;
+            st.layout_effect_cursor = 0;
             st.pending_effects.borrow_mut().clear();
+            st.pending_layout_effects.borrow_mut().clear();
             let app = st.root_app.clone()?;
             let Value::Function(f) = app else {
                 return None;
@@ -452,18 +550,16 @@ fn drain_flush_queue() {
         if let Some(f) = app_fn {
             let tree = f(&[]);
             HOOKS.with(|h| {
-                let mut map = h.borrow_mut();
-                if let Some(st) = map.get_mut(&root_id) {
+                if let Some(st) = h.borrow_mut().get_mut(&root_id) {
                     st.root_vnode = Some(tree.clone());
-                    HOSTS.with(|hosts| {
-                        let mut hm = hosts.borrow_mut();
-                        if let Some(host) = hm.get_mut(&root_id) {
-                            host.commit_root(&tree);
-                        }
-                    });
                 }
             });
+            let host = HOSTS.with(|hosts| hosts.borrow().get(&root_id).cloned());
+            if let Some(host) = host {
+                host.borrow_mut().commit_root(&tree);
+            }
             IN_FLUSH.set(false);
+            flush_pending_layout_effects(root_id);
             flush_pending_effects(root_id);
         }
 

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]