@tishlang/tish 1.13.2 → 2.0.1

package/crates/tish_runtime/src/ws.rs

@@ -82,6 +82,20 @@ fn unregister(id: u32) {
     CONNS.lock().unwrap().remove(&id);
 }
 
+/// Max simultaneous WebSocket connections. Each accepted conn registers in `CONNS` and
+/// spawns tasks + channels, freed only on close — unbounded accepts exhaust tasks/memory.
+/// Override with `TISH_WS_MAX_CONNS`; default 10000.
+fn max_ws_connections() -> usize {
+    use std::sync::OnceLock;
+    static MAX: OnceLock<usize> = OnceLock::new();
+    *MAX.get_or_init(|| {
+        std::env::var("TISH_WS_MAX_CONNS")
+            .ok()
+            .and_then(|v| v.parse().ok())
+            .unwrap_or(10_000)
+    })
+}
+
 fn conn_send(id: u32, data: String) -> bool {
     let guard = match CONNS.lock() {
         Ok(g) => g,
@@ -105,7 +119,7 @@ fn conn_receive(id: u32) -> Option<String> {
 /// Uses try_recv in a loop to avoid holding CONNS lock while blocking (prevents deadlock
 /// when connection closes and tokio task needs to unregister).
 fn conn_receive_timeout(id: u32, timeout_ms: u64) -> Option<String> {
-    let timeout_ms = timeout_ms.min(3600_000);
+    let timeout_ms = timeout_ms.min(3_600_000);
     let deadline = Instant::now() + Duration::from_millis(timeout_ms);
     let poll_interval = Duration::from_millis(50);
     loop {
@@ -149,11 +163,9 @@ fn conn_id_from_value(v: &Value) -> Option<u32> {
         Value::Object(o) => {
             let b = o.borrow();
             // Direct conn: { _id, send, ... }
-            if let Some(idv) = b.strings.get("_id") {
-                if let Value::Number(n) = idv {
-                    if n.is_finite() && *n >= 0.0 {
-                        return Some(*n as u32);
-                    }
+            if let Some(Value::Number(n)) = b.strings.get("_id") {
+                if n.is_finite() && *n >= 0.0 {
+                    return Some(*n as u32);
                 }
             }
             // Wrapper: { ws: conn, ... }
@@ -168,7 +180,7 @@ fn conn_id_from_value(v: &Value) -> Option<u32> {
 
 /// Native broadcast: send data to all conns in array except `except`. Avoids Tish-side method calls.
 pub fn ws_broadcast_native(args: &[Value]) -> Value {
-    let conns = match args.get(0) {
+    let conns = match args.first() {
         Some(Value::Array(a)) => a.borrow().clone(),
         _ => return Value::Null,
     };
@@ -232,7 +244,7 @@ fn conn_object(id: u32) -> Value {
                 .first()
                 .and_then(|v| match v {
                     Value::Number(n) if n.is_finite() && *n >= 0.0 => {
-                        Some((*n as u64).min(3600_000))
+                        Some((*n as u64).min(3_600_000))
                     }
                     _ => None,
                 })
@@ -366,6 +378,11 @@ pub fn web_socket_server_listen(args: &[Value]) -> Value {
                     Ok(s) => s,
                     Err(_) => break,
                 };
+                // Cap total connections — unbounded accepts would exhaust tasks/memory.
+                if CONNS.lock().map(|c| c.len()).unwrap_or(0) >= max_ws_connections() {
+                    drop(stream);
+                    continue;
+                }
                 let ws_stream = match tokio_tungstenite::accept_async(stream).await {
                     Ok(ws) => {
                         eprintln!(
@@ -446,7 +463,7 @@ pub fn web_socket_server_accept_timeout(args: &[Value]) -> Value {
         _ => return Value::Null,
     };
     let timeout_ms = match args.get(1) {
-        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => (*n as u64).min(3600_000),
+        Some(Value::Number(n)) if n.is_finite() && *n >= 0.0 => (*n as u64).min(3_600_000),
         _ => 100,
     };
     let mut map = match SERVER_RECV.lock() {
@@ -520,7 +537,7 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
             }
             clients_listen.borrow_mut().push(ws.clone());
             if let Value::Function(f) = cb {
-                let _ = f(&[ws]);
+                let _ = f.call(&[ws]);
             }
         }
         Value::Null
@@ -584,7 +601,7 @@ mod tests {
             for _ in 0..50 {
                 let recv_fn = wso.borrow().strings.get("receive").cloned();
                 if let Some(Value::Function(rf)) = recv_fn {
-                    let msg = rf(&[]);
+                    let msg = rf.call(&[]);
                     if !matches!(msg, Value::Null) {
                         let data = match msg {
                             Value::Object(ev) => ev
@@ -598,7 +615,7 @@ mod tests {
                         if let Some(Value::Function(sf)) =
                             wso.borrow().strings.get("send").cloned()
                         {
-                            let _ = sf(&[Value::String(data.into())]);
+                            let _ = sf.call(&[Value::String(data.into())]);
                         }
                         break;
                     }
@@ -619,7 +636,7 @@ mod tests {
         let Value::Function(send_f) = send else {
             panic!("no send");
         };
-        let _ = send_f(&[Value::String("hello".into())]);
+        let _ = send_f.call(&[Value::String("hello".into())]);
 
         let recv = co.borrow().strings.get("receive").cloned().unwrap();
         let Value::Function(recv_f) = recv else {
@@ -627,7 +644,7 @@ mod tests {
         };
         let mut got = Value::Null;
         for _ in 0..100 {
-            got = recv_f(&[]);
+            got = recv_f.call(&[]);
             if !matches!(got, Value::Null) {
                 break;
             }
@@ -673,7 +690,7 @@ mod tests {
             };
             // Poll until we get join
             for _ in 0..200 {
-                let msg = rf(&[]);
+                let msg = rf.call(&[]);
                 if !matches!(msg, Value::Null) {
                     let data = match &msg {
                         Value::Object(ev) => ev
@@ -710,7 +727,7 @@ mod tests {
             panic!("no send");
         };
         let join_msg = r#"{"type":"join","sessionId":"default","role":"agent","laneId":"ai-a"}"#;
-        let _ = send_f(&[Value::String(join_msg.into())]);
+        let _ = send_f.call(&[Value::String(join_msg.into())]);
 
         // Client uses receiveTimeout like the agent
         let recv_timeout = co
@@ -724,7 +741,7 @@ mod tests {
         };
         let timeout_arg = Value::Number(2000.0);
 
-        let got1 = recv_timeout_f(&[timeout_arg.clone()]);
+        let got1 = recv_timeout_f.call(&[timeout_arg.clone()]);
         let Value::Object(ev1) = got1 else {
             panic!("first recv: expected object, got {:?}", got1);
         };
@@ -740,7 +757,7 @@ mod tests {
             data1
         );
 
-        let got2 = recv_timeout_f(&[timeout_arg]);
+        let got2 = recv_timeout_f.call(&[timeout_arg]);
         let Value::Object(ev2) = got2 else {
             panic!("second recv: expected object, got {:?}", got2);
         };

package/crates/tish_runtime/tests/fetch_readable_stream.rs

@@ -65,7 +65,7 @@ fn fetch_readable_stream_read_chunks() {
         Value::Opaque(s) => s.as_ref(),
         _ => panic!("expected ReadableStream opaque"),
     };
-    let reader_val = stream.get_method("getReader").expect("getReader")(&[]);
+    let reader_val = stream.get_method("getReader").expect("getReader").call(&[]);
     let reader = match reader_val {
         Value::Opaque(r) => r,
         _ => panic!("expected reader opaque, got {:?}", reader_val),
@@ -73,7 +73,7 @@ fn fetch_readable_stream_read_chunks() {
 
     let mut acc = Vec::new();
     loop {
-        let read_p = reader.get_method("read").expect("read")(&[]);
+        let read_p = reader.get_method("read").expect("read").call(&[]);
         let chunk = await_promise(read_p);
         let (done, chunk_bytes) = match chunk {
             Value::Object(o) => {

package/crates/tish_ui/src/jsx.rs

@@ -142,6 +142,11 @@ fn collect_fun_decl_names_stmt(stmt: &Statement, names: &mut HashSet<String>) {
                 collect_fun_decl_names_stmt(s, names);
             }
         }
+        Statement::Multi { statements, .. } => {
+            for s in statements {
+                collect_fun_decl_names_stmt(s, names);
+            }
+        }
         Statement::VarDecl { init, .. } => {
             if let Some(e) = init {
                 collect_fun_decl_names_expr(e, names);
@@ -315,6 +320,9 @@ fn collect_fun_decl_names_expr(expr: &Expr, names: &mut HashSet<String>) {
         Expr::Await { operand, .. } | Expr::TypeOf { operand, .. } => {
             collect_fun_decl_names_expr(operand, names);
         }
+        Expr::Delete { target, .. } => {
+            collect_fun_decl_names_expr(target, names);
+        }
         Expr::CompoundAssign { value, .. } | Expr::LogicalAssign { value, .. } => {
             collect_fun_decl_names_expr(value, names);
         }
@@ -537,6 +545,7 @@ fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
     use tishlang_ast::{ExportDeclaration, Statement};
     match stmt {
         Statement::Block { statements, .. } => statements.iter().any(stmt_contains_jsx),
+        Statement::Multi { statements, .. } => statements.iter().any(stmt_contains_jsx),
         Statement::VarDecl { init, .. } => init.as_ref().is_some_and(expr_contains_jsx),
         Statement::VarDeclDestructure { init, .. } => expr_contains_jsx(init),
         Statement::ExprStmt { expr, .. } => expr_contains_jsx(expr),
@@ -653,6 +662,7 @@ fn expr_contains_jsx(expr: &Expr) -> bool {
         Expr::TemplateLiteral { exprs, .. } => exprs.iter().any(expr_contains_jsx),
         Expr::Await { operand, .. } => expr_contains_jsx(operand),
         Expr::TypeOf { operand, .. } => expr_contains_jsx(operand),
+        Expr::Delete { target, .. } => expr_contains_jsx(target),
         Expr::PostfixInc { .. }
         | Expr::PrefixInc { .. }
         | Expr::PostfixDec { .. }

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

@@ -17,13 +17,16 @@ 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;
 
+/// Shared, interior-mutable handle to one root's host backend.
+type HostHandle = Rc<RefCell<Box<dyn Host>>>;
+
 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, 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);
+    static CURRENT_ROOT: Cell<Option<RootId>> = const { Cell::new(None) };
+    static HOSTS: RefCell<HashMap<RootId, HostHandle>> = RefCell::new(HashMap::new());
+    static NEXT_DYNAMIC_ROOT_ID: Cell<RootId> = const { Cell::new(2) };
+    static IN_FLUSH: Cell<bool> = const { Cell::new(false) };
+    static IN_EFFECT_FLUSH: Cell<bool> = const { Cell::new(false) };
 }
 
 /// Allocate an id for an additional in-process window (starts at 2; 1 is legacy primary).
@@ -121,6 +124,9 @@ struct PendingEffect {
     new_deps: Vec<Value>,
 }
 
+/// Per-slot last dependency snapshot and cached value for `useMemo`.
+type MemoCache = Rc<RefCell<Vec<Option<(Vec<Value>, Value)>>>>;
+
 /// Hook storage for one `createRoot().render(App)` tree.
 pub struct HookState {
     pub state_slots: Rc<RefCell<Vec<Value>>>,
@@ -129,7 +135,7 @@ pub struct HookState {
     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_cache: MemoCache,
     pub memo_cursor: usize,
     effect_cells: Rc<RefCell<Vec<EffectCell>>>,
     effect_cursor: usize,
@@ -165,10 +171,8 @@ impl Default for HookState {
 
 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(&[]);
-            }
+        if let Some(Value::Function(f)) = cell.cleanup.take() {
+            let _ = f.call(&[]);
         }
     }
 }
@@ -252,7 +256,7 @@ pub fn native_use_state(args: &[Value]) -> Value {
                     }
                     let prev = st.state_slots.borrow()[idx].clone();
                     let new_v = match &arg {
-                        Value::Function(f) => f(&[prev.clone()]),
+                        Value::Function(f) => f.call(std::slice::from_ref(&prev)),
                         _ => arg.clone(),
                     };
                     if memo_dep_eq(&prev, &new_v) {
@@ -301,7 +305,7 @@ pub fn native_use_memo(args: &[Value]) -> Value {
         if reuse {
             return c[i].as_ref().unwrap().1.clone();
         }
-        let produced = factory(&[]);
+        let produced = factory.call(&[]);
         c[i] = Some((deps, produced.clone()));
         produced
     })
@@ -419,10 +423,10 @@ fn flush_pending_effects_for(
             cells[p.slot].cleanup.take()
         };
         if let Some(Value::Function(f)) = cleanup_fn {
-            let _ = f(&[]);
+            let _ = f.call(&[]);
         }
         let run_result = if let Value::Function(f) = &p.effect_fn {
-            f(&[])
+            f.call(&[])
         } else {
             Value::Null
         };
@@ -548,7 +552,7 @@ fn drain_flush_queue_on_current_thread() {
         });
 
         if let Some(f) = app_fn {
-            let tree = f(&[]);
+            let tree = f.call(&[]);
             HOOKS.with(|h| {
                 if let Some(st) = h.borrow_mut().get_mut(&root_id) {
                     st.root_vnode = Some(tree.clone());

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

@@ -29,7 +29,7 @@ pub fn fragment_value() -> Value {
 /// Returns true if `tag` refers to [`fragment_value`].
 pub fn is_fragment_tag(tag: &Value) -> bool {
     match tag {
-        Value::String(s) => s.as_ref() == FRAGMENT_SENTINEL,
+        Value::String(s) => s.as_str() == FRAGMENT_SENTINEL,
         Value::Symbol(s) => s.registry_key.as_deref() == Some("tish.fragment"),
         _ => false,
     }
@@ -46,17 +46,24 @@ pub fn ui_text(args: &[Value]) -> Value {
 
 /// Vnode factory: `h(tag, props, children)` (Lattish-compatible shape).
 pub fn ui_h(args: &[Value]) -> Value {
-    let tag = args.get(0).cloned().unwrap_or(Value::Null);
+    let tag = args.first().cloned().unwrap_or(Value::Null);
     let props = args.get(1).cloned().unwrap_or(Value::Null);
     let children_arg = args.get(2).cloned().unwrap_or(Value::Null);
 
     let children_vec = normalize_children_list(children_arg);
 
     if let Value::Function(f) = &tag {
-        let mut merged = if matches!(props, Value::Null) {
+        let mut merged: ObjectMap = if matches!(props, Value::Null) {
             ObjectMap::default()
         } else if let Value::Object(obj) = props {
-            obj.borrow().strings.clone()
+            // `ObjectData.strings` is an insertion-ordered `PropMap`; `Value::object` takes an
+            // `ObjectMap` (`AHashMap`). Copy the entries across (object property order is not
+            // observable for a merged props map here).
+            obj.borrow()
+                .strings
+                .iter()
+                .map(|(k, v)| (Arc::clone(k), v.clone()))
+                .collect()
         } else {
             ObjectMap::default()
         };
@@ -66,7 +73,7 @@ pub fn ui_h(args: &[Value]) -> Value {
                 Value::Array(VmRef::new(children_vec.clone())),
             );
         }
-        return f(&[Value::object(merged)]);
+        return f.call(&[Value::object(merged)]);
     }
 
     if is_fragment_tag(&tag) {
@@ -74,7 +81,7 @@ pub fn ui_h(args: &[Value]) -> Value {
     }
 
     let tag_str: Arc<str> = match tag {
-        Value::String(s) => s,
+        Value::String(s) => Arc::from(s.as_str()),
         _ => return Value::Null,
     };
 
@@ -105,7 +112,7 @@ fn flatten_vnode_children(items: &[Value]) -> Vec<Value> {
 
 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));
+    m.insert(Arc::from("tag"), Value::String(tag.as_ref().into()));
     m.insert(
         Arc::from("props"),
         if matches!(props, Value::Null) {
@@ -143,15 +150,11 @@ pub trait Host {
 }
 
 /// No-op / test host that only stores the last committed tree.
+#[derive(Default)]
 pub struct HeadlessHost {
     pub last: Option<Value>,
 }
 
-impl Default for HeadlessHost {
-    fn default() -> Self {
-        Self { last: None }
-    }
-}
 
 impl Host for HeadlessHost {
     fn commit_root(&mut self, vnode: &Value) {

package/crates/tish_vm/Cargo.toml

@@ -8,7 +8,10 @@ license-file = { workspace = true }
 repository = { workspace = true }
 [features]
 default = []
-regex = ["tishlang_core/regex"]
+# RegExp needs the runtime's regex impls (regexp_new / regexp_test / regexp_exec and the
+# regex-aware String methods) so the VM routes through the SAME code as the rust backend.
+# Mirror the fs/http pattern: pull in the optional runtime crate + its regex feature.
+regex = ["tishlang_core/regex", "dep:tishlang_runtime", "tishlang_runtime/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.
@@ -20,6 +23,7 @@ wasm = ["dep:wasm-bindgen"]
 # (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"]
+tty = ["dep:tishlang_runtime", "tishlang_runtime/tty"]
 # 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
@@ -45,3 +49,12 @@ tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.4", features = ["wasm_js"] }
+
+# Numeric JIT (native codegen slice 1). Not built for wasm — cranelift-jit emits host
+# machine code and cannot target wasm32. The wasm/wasi VM keeps the interpreter path.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+cranelift = "0.130"
+cranelift-jit = "0.130"
+cranelift-module = "0.130"
+cranelift-native = "0.130"
+stacker = "0.1"