@tishlang/tish 1.7.0 → 1.9.0

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

@@ -1,82 +1,423 @@
-//! Minimal hook state: `useState` + render flush (Lattish-style cursor reset).
+//! Minimal hook state: `useState`, `useMemo`, and render flush (Lattish-style cursor reset).
+//! Supports multiple independent roots (`RootId`) in one thread.
 
 use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
 use std::rc::Rc;
 
-use tishlang_core::{ObjectMap, Value};
+use tishlang_core::{ObjectMap, Value, VmRef};
 
-use super::ACTIVE_HOST;
+use super::Host;
+
+/// Opaque id for one `createRoot().render(App)` tree in this thread.
+pub type RootId = u64;
+
+/// First root: `install_thread_local_host` and `native_create_root` without an id argument.
+pub const LEGACY_ROOT_ID: RootId = 1;
 
 thread_local! {
-    pub static HOOK: RefCell<HookState> = RefCell::new(HookState::default());
+    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 NEXT_DYNAMIC_ROOT_ID: Cell<RootId> = Cell::new(2);
     static IN_FLUSH: Cell<bool> = Cell::new(false);
 }
 
+/// Allocate an id for an additional in-process window (starts at 2; 1 is legacy primary).
+pub fn alloc_root_id() -> RootId {
+    NEXT_DYNAMIC_ROOT_ID.with(|n| {
+        let id = n.get();
+        n.set(id.saturating_add(1).max(2));
+        id
+    })
+}
+
+fn ensure_hook_entry(root_id: RootId) {
+    HOOKS.with(|h| {
+        h.borrow_mut().entry(root_id).or_default();
+    });
+}
+
+/// Install the host for a specific root. Replaces any previous host for that id.
+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);
+    });
+}
+
+/// Legacy: install host for [`LEGACY_ROOT_ID`] (same as `macos.run` / single-window tools).
+#[allow(dead_code)] // Emitted Rust / hosts call via `tishlang_ui` re-exports; unused inside this crate.
+pub fn install_thread_local_host(host: Box<dyn Host>) {
+    install_host_for_root(LEGACY_ROOT_ID, host);
+}
+
+/// Remove hook state and run effect cleanups. Safe to call while the host still exists (e.g. before
+/// dropping AppKit objects that might receive async callbacks).
+pub fn unregister_root_hooks_and_effects(root_id: RootId) {
+    HOOKS.with(|h| {
+        if let Some(st) = h.borrow_mut().remove(&root_id) {
+            run_all_effect_cleanups(st.effect_cells.as_ref());
+        }
+    });
+}
+
+/// Drop the [`Host`] for `root_id`. Defer after `windowWillClose:` returns when the host retains the
+/// window delegate object that is still executing that callback.
+pub fn drop_host_for_root(root_id: RootId) {
+    HOSTS.with(|h| {
+        h.borrow_mut().remove(&root_id);
+    });
+}
+
+pub fn unregister_root(root_id: RootId) {
+    unregister_root_hooks_and_effects(root_id);
+    drop_host_for_root(root_id);
+}
+
+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()))
+    })
+}
+
+/// Prefer [`with_host_for_root`]; kept for call sites that assume a single primary root.
+#[allow(dead_code)]
+pub fn with_thread_local_host<R>(f: impl FnOnce(&mut dyn Host) -> R) -> Option<R> {
+    with_host_for_root(LEGACY_ROOT_ID, f)
+}
+
+/// Root currently rendering or running hook flush (`None` outside that scope).
+pub fn current_root_id() -> Option<RootId> {
+    CURRENT_ROOT.get()
+}
+
+/// Sets [`CURRENT_ROOT`] for the duration of `f` so `window.*` and similar APIs target this tree.
+pub fn run_with_current_root<R>(root_id: RootId, f: impl FnOnce() -> R) -> R {
+    let prev = CURRENT_ROOT.get();
+    CURRENT_ROOT.set(Some(root_id));
+    let out = f();
+    CURRENT_ROOT.set(prev);
+    out
+}
+
+/// One `useEffect` slot: committed dependency snapshot and optional cleanup from the last run.
 #[derive(Default)]
+struct EffectCell {
+    committed_deps: Option<Vec<Value>>,
+    cleanup: Option<Value>,
+}
+
+struct PendingEffect {
+    slot: usize,
+    effect_fn: Value,
+    new_deps: Vec<Value>,
+}
+
+/// Hook storage for one `createRoot().render(App)` tree.
 pub struct HookState {
     pub state_slots: Rc<RefCell<Vec<Value>>>,
     pub cursor: usize,
     pub root_app: Option<Value>,
     pub root_vnode: Option<Value>,
     pub flush_scheduled: bool,
+    /// Per-slot: last dependency tuple snapshot and cached value from `useMemo`.
+    pub memo_cache: Rc<RefCell<Vec<Option<(Vec<Value>, Value)>>>>,
+    pub memo_cursor: usize,
+    effect_cells: Rc<RefCell<Vec<EffectCell>>>,
+    effect_cursor: usize,
+    pending_effects: Rc<RefCell<Vec<PendingEffect>>>,
+}
+
+impl Default for HookState {
+    fn default() -> Self {
+        Self {
+            state_slots: Rc::new(RefCell::new(Vec::new())),
+            cursor: 0,
+            root_app: None,
+            root_vnode: None,
+            flush_scheduled: false,
+            memo_cache: Rc::new(RefCell::new(Vec::new())),
+            memo_cursor: 0,
+            effect_cells: Rc::new(RefCell::new(Vec::new())),
+            effect_cursor: 0,
+            pending_effects: Rc::new(RefCell::new(Vec::new())),
+        }
+    }
+}
+
+fn run_all_effect_cleanups(cells: &RefCell<Vec<EffectCell>>) {
+    for cell in cells.borrow_mut().iter_mut() {
+        if let Some(c) = cell.cleanup.take() {
+            if let Value::Function(f) = c {
+                let _ = f(&[]);
+            }
+        }
+    }
 }
 
 impl HookState {
     pub fn reset_for_new_root(&mut self) {
+        run_all_effect_cleanups(self.effect_cells.as_ref());
+        self.effect_cells.borrow_mut().clear();
+        self.effect_cursor = 0;
+        self.pending_effects.borrow_mut().clear();
         self.state_slots.borrow_mut().clear();
         self.cursor = 0;
         self.root_vnode = None;
         self.flush_scheduled = false;
+        self.memo_cache.borrow_mut().clear();
+        self.memo_cursor = 0;
     }
 }
 
+fn memo_dep_eq(a: &Value, b: &Value) -> bool {
+    match (a, b) {
+        (Value::Number(x), Value::Number(y)) => {
+            if x.is_nan() && y.is_nan() {
+                return true;
+            }
+            x == y
+        }
+        (Value::String(x), Value::String(y)) => x == y,
+        (Value::Bool(x), Value::Bool(y)) => x == y,
+        (Value::Null, Value::Null) => true,
+        (Value::Array(ax), Value::Array(bx)) => {
+            let ab = ax.borrow();
+            let bb = bx.borrow();
+            if ab.len() != bb.len() {
+                return false;
+            }
+            ab.iter()
+                .zip(bb.iter())
+                .all(|(x, y)| memo_dep_eq(x, y))
+        }
+        _ => false,
+    }
+}
+
+fn memo_deps_unchanged(prev: &[Value], next: &[Value]) -> bool {
+    prev.len() == next.len()
+        && prev
+            .iter()
+            .zip(next.iter())
+            .all(|(a, b)| memo_dep_eq(a, b))
+}
+
+fn root_id_for_hooks() -> RootId {
+    CURRENT_ROOT.get().unwrap_or(LEGACY_ROOT_ID)
+}
+
 /// `useState(initial)` → `[state, setState]` as a Tish array.
 pub fn native_use_state(args: &[Value]) -> Value {
     let initial = args.first().cloned().unwrap_or(Value::Null);
-    HOOK.with(|h| {
-        let mut st = h.borrow_mut();
+    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.cursor;
         st.cursor += 1;
-        let slots = Rc::clone(&st.state_slots);
+        let slots = &st.state_slots.clone();
         while i >= slots.borrow().len() {
             slots.borrow_mut().push(initial.clone());
         }
         let current = slots.borrow()[i].clone();
         let idx = i;
-        let setter = Value::Function(Rc::new(move |a: &[Value]| {
-            let new_v = a.first().cloned().unwrap_or(Value::Null);
-            slots.borrow_mut()[idx] = new_v;
-            schedule_flush();
+        let setter = Value::native(move |a: &[Value]| {
+            let arg = a.first().cloned().unwrap_or(Value::Null);
+            HOOKS.with(|hooks| {
+                if let Some(st) = hooks.borrow_mut().get_mut(&root_id) {
+                    let slot_len = st.state_slots.borrow().len();
+                    if idx >= slot_len {
+                        st.flush_scheduled = true;
+                        return;
+                    }
+                    let prev = st.state_slots.borrow()[idx].clone();
+                    let new_v = match &arg {
+                        Value::Function(f) => f(&[prev.clone()]),
+                        _ => arg.clone(),
+                    };
+                    if memo_dep_eq(&prev, &new_v) {
+                        return;
+                    }
+                    st.state_slots.borrow_mut()[idx] = new_v;
+                    st.flush_scheduled = true;
+                }
+            });
+            if !IN_FLUSH.get() {
+                drain_flush_queue();
+            }
             Value::Null
-        }));
-        Value::Array(Rc::new(RefCell::new(vec![current, setter])))
+        });
+        Value::Array(VmRef::new(vec![current, setter]))
+    })
+}
+
+/// `useMemo(factory, deps?)` — caches `factory()` until `deps` changes (shallow compare per slot).
+pub fn native_use_memo(args: &[Value]) -> Value {
+    let Some(Value::Function(factory)) = args.first() else {
+        return Value::Null;
+    };
+    let factory = factory.clone();
+    let deps: Vec<Value> = match args.get(1) {
+        Some(Value::Array(a)) => a.borrow().clone(),
+        Some(other) => vec![other.clone()],
+        None => vec![],
+    };
+
+    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.memo_cursor;
+        st.memo_cursor += 1;
+        let cache = &st.memo_cache.clone();
+        let mut c = cache.borrow_mut();
+        while c.len() <= i {
+            c.push(None);
+        }
+        let reuse = match &c[i] {
+            Some((old_deps, _)) => memo_deps_unchanged(old_deps, &deps),
+            None => false,
+        };
+        if reuse {
+            return c[i].as_ref().unwrap().1.clone();
+        }
+        let produced = factory(&[]);
+        c[i] = Some((deps, produced.clone()));
+        produced
     })
 }
 
-/// `createRoot(container)` → `{ render: (App) => { ... } }` (container ignored for headless native).
+/// `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 {
+    let Some(Value::Function(effect_fn)) = args.first() else {
+        return Value::Null;
+    };
+    let effect_fn = effect_fn.clone();
+    let deps: Vec<Value> = match args.get(1) {
+        Some(Value::Array(a)) => a.borrow().clone(),
+        Some(other) => vec![other.clone()],
+        None => vec![],
+    };
+
+    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.effect_cursor;
+        st.effect_cursor += 1;
+        let cells = &st.effect_cells.clone();
+        let mut cells_b = cells.borrow_mut();
+        while cells_b.len() <= i {
+            cells_b.push(EffectCell::default());
+        }
+        let should_run = match &cells_b[i].committed_deps {
+            None => true,
+            Some(old) => !memo_deps_unchanged(old, &deps),
+        };
+        drop(cells_b);
+
+        if should_run {
+            st.pending_effects.borrow_mut().push(PendingEffect {
+                slot: i,
+                effect_fn: Value::Function(effect_fn),
+                new_deps: deps,
+            });
+        }
+        Value::Null
+    })
+}
+
+fn flush_pending_effects(root_id: RootId) {
+    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()))
+            .unwrap_or_default()
+    });
+    let cells_rc = HOOKS.with(|h| {
+        h.borrow()
+            .get(&root_id)
+            .map(|st| st.effect_cells.clone())
+    });
+    let Some(cells_rc) = cells_rc else {
+        return;
+    };
+
+    for p in pending {
+        // Never hold `effect_cells` across user cleanup/effect: they may call `setState` →
+        // `drain_flush_queue` → `native_use_effect`, which must `borrow_mut` the same RefCell.
+        let cleanup_fn = {
+            let mut cells = cells_rc.borrow_mut();
+            while cells.len() <= p.slot {
+                cells.push(EffectCell::default());
+            }
+            cells[p.slot].cleanup.take()
+        };
+        if let Some(Value::Function(f)) = cleanup_fn {
+            let _ = f(&[]);
+        }
+        let run_result = if let Value::Function(f) = &p.effect_fn {
+            f(&[])
+        } else {
+            Value::Null
+        };
+        {
+            let mut cells = cells_rc.borrow_mut();
+            while cells.len() <= p.slot {
+                cells.push(EffectCell::default());
+            }
+            let cell = &mut cells[p.slot];
+            cell.cleanup = match run_result {
+                Value::Function(f) => Some(Value::Function(f)),
+                _ => None,
+            };
+            cell.committed_deps = Some(p.new_deps);
+        }
+    }
+}
+
+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,
+        _ => LEGACY_ROOT_ID,
+    }
+}
+
+/// `createRoot(container?)` or `createRoot(rootId)` → `{ render: (App) => { ... } }`.
+/// Pass a positive integer as the first argument to bind this root to a host installed via
+/// [`install_host_for_root`].
 pub fn native_create_root(args: &[Value]) -> Value {
-    let _container = args.first();
-    let render_fn = Value::Function(Rc::new(|app_args: &[Value]| {
+    let root_id = parse_root_id_arg(args);
+    ensure_hook_entry(root_id);
+    let render_fn = Value::native(move |app_args: &[Value]| {
         let app = app_args.first().cloned().unwrap_or(Value::Null);
-        HOOK.with(|h| {
-            let mut st = h.borrow_mut();
+        HOOKS.with(|h| {
+            let mut map = h.borrow_mut();
+            let st = map.entry(root_id).or_default();
             st.reset_for_new_root();
             st.root_app = Some(app);
             st.flush_scheduled = true;
         });
         drain_flush_queue();
         Value::Null
-    }));
-    Value::Object(Rc::new(RefCell::new(ObjectMap::from([(
+    });
+    Value::Object(VmRef::new(ObjectMap::from([(
         std::sync::Arc::from("render"),
         render_fn,
-    )]))))
+    )])))
 }
 
 /// Request a re-render (coalesced; safe if called during flush).
 pub fn schedule_flush() {
-    HOOK.with(|h| {
-        h.borrow_mut().flush_scheduled = true;
+    let root_id = root_id_for_hooks();
+    HOOKS.with(|h| {
+        if let Some(st) = h.borrow_mut().get_mut(&root_id) {
+            st.flush_scheduled = true;
+        }
     });
     if IN_FLUSH.get() {
         return;
@@ -86,37 +427,57 @@ pub fn schedule_flush() {
 
 fn drain_flush_queue() {
     loop {
-        let run = HOOK.with(|h| {
-            let mut st = h.borrow_mut();
-            if st.flush_scheduled {
-                st.flush_scheduled = false;
-                true
-            } else {
-                false
-            }
+        let root_id = HOOKS.with(|h| {
+            h.borrow()
+                .iter()
+                .find(|(_, st)| st.flush_scheduled)
+                .map(|(id, _)| *id)
         });
-        if !run {
+        let Some(root_id) = root_id else {
             break;
-        }
+        };
+
         IN_FLUSH.set(true);
-        HOOK.with(|h| {
-            let mut st = h.borrow_mut();
+        CURRENT_ROOT.set(Some(root_id));
+        HOOKS.with(|h| {
+            if let Some(st) = h.borrow_mut().get_mut(&root_id) {
+                st.flush_scheduled = false;
+            }
+        });
+
+        let app_fn = HOOKS.with(|h| {
+            let mut map = h.borrow_mut();
+            let st = map.get_mut(&root_id)?;
             st.cursor = 0;
-            let Some(app) = st.root_app.clone() else {
-                return;
-            };
+            st.memo_cursor = 0;
+            st.effect_cursor = 0;
+            st.pending_effects.borrow_mut().clear();
+            let app = st.root_app.clone()?;
             let Value::Function(f) = app else {
-                return;
+                return None;
             };
+            Some(f)
+        });
+
+        if let Some(f) = app_fn {
             let tree = f(&[]);
-            st.root_vnode = Some(tree.clone());
-            ACTIVE_HOST.with(|host_cell| {
-                let mut host_opt = host_cell.borrow_mut();
-                if let Some(host) = host_opt.as_deref_mut() {
-                    host.commit_root(&tree);
+            HOOKS.with(|h| {
+                let mut map = h.borrow_mut();
+                if let Some(st) = map.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);
+                        }
+                    });
                 }
             });
-        });
+            IN_FLUSH.set(false);
+            flush_pending_effects(root_id);
+        }
+
+        CURRENT_ROOT.set(None);
         IN_FLUSH.set(false);
     }
 }

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

@@ -6,9 +6,14 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
-pub use hooks::{native_create_root, native_use_state, schedule_flush, HookState, HOOK};
+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,
+    LEGACY_ROOT_ID, RootId,
+};
 
-use tishlang_core::{ObjectMap, Value};
+use tishlang_core::{ObjectMap, Value, VmRef};
 
 /// Sentinel string for `Fragment` (native). JS/Lattish uses `Symbol`; hosts compare via equality.
 pub const FRAGMENT_SENTINEL: &str = "__tish_ui_Fragment__";
@@ -51,10 +56,10 @@ pub fn ui_h(args: &[Value]) -> Value {
         if !children_vec.is_empty() {
             merged.insert(
                 Arc::from("children"),
-                Value::Array(Rc::new(RefCell::new(children_vec.clone()))),
+                Value::Array(VmRef::new(children_vec.clone())),
             );
         }
-        return f(&[Value::Object(Rc::new(RefCell::new(merged)))]);
+        return f(&[Value::Object(VmRef::new(merged))]);
     }
 
     if is_fragment_tag(&tag) {
@@ -72,11 +77,25 @@ pub fn ui_h(args: &[Value]) -> Value {
 fn normalize_children_list(children_arg: Value) -> Vec<Value> {
     match children_arg {
         Value::Null => vec![],
-        Value::Array(a) => a.borrow().clone(),
+        Value::Array(a) => flatten_vnode_children(&a.borrow()),
         other => vec![other],
     }
 }
 
+/// JSX often passes `{items.map(...)}` as one slot in the children array. Treat nested `Value::Array`
+/// like React: splice them into the parent list so hosts never see a raw array vnode.
+fn flatten_vnode_children(items: &[Value]) -> Vec<Value> {
+    let mut out = Vec::new();
+    for c in items {
+        match c {
+            Value::Array(inner) => out.extend(flatten_vnode_children(&inner.borrow())),
+            Value::Null => {}
+            _ => out.push(c.clone()),
+        }
+    }
+    out
+}
+
 fn vnode_element(tag: Arc<str>, props: Value, children: Vec<Value>) -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("tag"), Value::String(tag));
@@ -90,10 +109,10 @@ fn vnode_element(tag: Arc<str>, props: Value, children: Vec<Value>) -> Value {
     );
     m.insert(
         Arc::from("children"),
-        Value::Array(Rc::new(RefCell::new(children))),
+        Value::Array(VmRef::new(children)),
     );
     m.insert(Arc::from("_el"), Value::Null);
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn vnode_fragment(children: Vec<Value>) -> Value {
@@ -102,16 +121,24 @@ fn vnode_fragment(children: Vec<Value>) -> Value {
     m.insert(Arc::from("props"), Value::Null);
     m.insert(
         Arc::from("children"),
-        Value::Array(Rc::new(RefCell::new(children))),
+        Value::Array(VmRef::new(children)),
     );
     m.insert(Arc::from("_el"), Value::Null);
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 /// Pluggable UI backend (Floem, DOM, SwiftUI, …). Main-thread / single-threaded by default.
 pub trait Host {
     /// Apply a new root vnode (after each render flush).
     fn commit_root(&mut self, vnode: &Value);
+    /// Content area width changed (e.g. window resize); default no-op.
+    fn content_width_changed(&mut self, _width: f64) {}
+    /// Called once from the main queue shortly after the window is ordered on-screen. Split /
+    /// sidebar hosts can use this to re-layout when pane bounds were still provisional during the
+    /// first commit.
+    fn after_window_shown(&mut self) {}
+    /// Clear native control target/action (and similar) before the host is dropped — e.g. window close.
+    fn detach_native_actions(&mut self) {}
 }
 
 /// No-op / test host that only stores the last committed tree.

package/crates/tish_vm/Cargo.toml

@@ -9,13 +9,23 @@ repository = { workspace = true }
 [features]
 default = []
 regex = ["tishlang_core/regex"]
+# Propagate `send-values` so that every native-function closure we build
+# in the VM (array / string / object methods) picks up the right
+# `Rc<dyn Fn>` vs `Arc<dyn Fn + Send + Sync>` wrapper at compile time.
+send-values = ["tishlang_core/send-values", "tishlang_builtins/send-values"]
 # For wasm32 target: use web_sys console for output
 wasm = ["dep:wasm-bindgen"]
-# Built-in modules: fs, http, process (for bytecode LoadNativeExport)
-fs = ["tishlang_runtime/fs"]
-process = ["tishlang_runtime/process"]
-http = ["tishlang_runtime/http"]
-ws = ["tishlang_runtime/ws"]
+# Built-in modules: fs, http, process (for bytecode LoadNativeExport).
+# `dep:tishlang_runtime` is required so enabling e.g. `http` always activates the optional runtime crate
+# (some Cargo/cache combinations only saw `tishlang_runtime/http` and built VM stubs without http).
+fs = ["dep:tishlang_runtime", "tishlang_runtime/fs"]
+process = ["dep:tishlang_runtime", "tishlang_runtime/process"]
+# Timer globals + `tish:timers` LoadNativeExport (uses tishlang_runtime TLS timer registry).
+timers = ["dep:tishlang_runtime"]
+# Any HTTP build needs Send-safe values so handlers can be dispatched
+# across worker threads or processes. HTTP implies timers (fetch/Promise often pair with setTimeout).
+http = ["dep:tishlang_runtime", "tishlang_runtime/http", "send-values", "timers"]
+ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
 [dependencies]
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }