@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_runtime/src/promise.rs

@@ -1,76 +1,235 @@
-//! Promise static methods for compiled Tish (resolve, reject, all, race).
+//! Promise helpers for the bytecode VM and native codegen (`Promise.resolve`, etc.).
+//!
+//! The global `Promise` value is an **object** with a `__call` entry so the VM can
+//! invoke `Promise(executor)` like `new Promise(executor)` in JS. Static methods live
+//! on the same object (`resolve`, `reject`, `all`, `race`).
 
-use std::cell::RefCell;
-use std::rc::Rc;
-use std::sync::Arc;
-use tishlang_core::{ObjectMap, Value};
+use std::sync::mpsc;
+use std::sync::{Arc, Mutex};
 
-/// Promise.resolve(value) - returns the value (immediate resolve).
+use tishlang_core::{ObjectMap, TishPromise, Value, VmRef};
+
+/// Fulfilled or rejected before anyone awaits — `block_until_settled` consumes the result once.
+pub struct ImmediateSettledPromise {
+    slot: Mutex<Option<Result<Value, Value>>>,
+}
+
+impl ImmediateSettledPromise {
+    fn new(result: Result<Value, Value>) -> Self {
+        Self {
+            slot: Mutex::new(Some(result)),
+        }
+    }
+}
+
+impl TishPromise for ImmediateSettledPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        self.slot
+            .lock()
+            .unwrap()
+            .take()
+            .unwrap_or(Err(Value::String(
+                "Promise already settled or consumed".into(),
+            )))
+    }
+}
+
+fn fulfilled(v: Value) -> Value {
+    Value::Promise(Arc::new(ImmediateSettledPromise::new(Ok(v))))
+}
+
+fn rejected(v: Value) -> Value {
+    Value::Promise(Arc::new(ImmediateSettledPromise::new(Err(v))))
+}
+
+fn flatten_chain_out(v: Value) -> std::result::Result<Value, Value> {
+    match v {
+        Value::Promise(p) => p.block_until_settled(),
+        other => Ok(other),
+    }
+}
+
+/// `Promise(executor)` — executor runs synchronously; `resolve` / `reject` unblock `recv`.
+struct DeferredChannelPromise {
+    rx: Mutex<Option<mpsc::Receiver<Result<Value, Value>>>>,
+}
+
+impl TishPromise for DeferredChannelPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        let rx = self.rx.lock().unwrap().take();
+        match rx {
+            Some(r) => r.recv().unwrap_or(Err(Value::String(
+                "Promise executor did not call resolve or reject".into(),
+            ))),
+            None => Err(Value::String(
+                "Promise already consumed or settled".into(),
+            )),
+        }
+    }
+}
+
+/// `.then` / `.catch` chain: when awaited, settle the predecessor then optionally invoke a handler.
+pub struct ThenPromise {
+    pred: Arc<dyn TishPromise>,
+    on_fulfilled: Option<Value>,
+    on_rejected: Option<Value>,
+}
+
+impl TishPromise for ThenPromise {
+    fn block_until_settled(&self) -> std::result::Result<Value, Value> {
+        match self.pred.block_until_settled() {
+            Ok(v) => {
+                if let Some(Value::Function(f)) = &self.on_fulfilled {
+                    flatten_chain_out(f(&[v]))
+                } else {
+                    Ok(v)
+                }
+            }
+            Err(e) => {
+                if let Some(Value::Function(f)) = &self.on_rejected {
+                    flatten_chain_out(f(&[e]))
+                } else {
+                    Err(e)
+                }
+            }
+        }
+    }
+}
+
+/// `Promise.resolve(value)` — adopt promises, otherwise wrap in a fulfilled promise.
 pub fn promise_resolve(args: &[Value]) -> Value {
-    args.first().cloned().unwrap_or(Value::Null)
+    match args.first() {
+        Some(Value::Promise(p)) => Value::Promise(Arc::clone(p)),
+        Some(v) => fulfilled(v.clone()),
+        None => fulfilled(Value::Null),
+    }
 }
 
-/// Promise.reject(value) - returns value as "rejected" placeholder.
-/// Note: await on this in native compile may not throw; use try/catch in interpreter for full support.
+/// `Promise.reject(reason)` — always a rejected promise.
 pub fn promise_reject(args: &[Value]) -> Value {
-    args.first().cloned().unwrap_or(Value::Null)
+    rejected(
+        args.first()
+            .cloned()
+            .unwrap_or(Value::Null),
+    )
 }
 
-/// Promise.all(iterable) - awaits each Promise in the array, returns array of resolved values.
+/// `Promise.all(iterable)` — block on each promise in order; non-promises pass through.
 pub fn promise_all(args: &[Value]) -> Value {
     match args.first() {
         Some(Value::Array(arr)) => {
-            let arr = arr.borrow();
-            let resolved: Vec<Value> = arr
-                .iter()
-                .map(|v| {
-                    if let Value::Promise(p) = v {
-                        match tishlang_core::TishPromise::block_until_settled(p.as_ref()) {
-                            Ok(val) => val,
-                            Err(rejection) => rejection,
-                        }
-                    } else {
-                        v.clone()
+            let mut out: Vec<Value> = Vec::new();
+            for v in arr.borrow().iter() {
+                let item = if let Value::Promise(p) = v {
+                    match p.block_until_settled() {
+                        Ok(x) => x,
+                        Err(rej) => return rejected(rej),
                     }
-                })
-                .collect();
-            Value::Array(Rc::new(RefCell::new(resolved)))
+                } else {
+                    v.clone()
+                };
+                out.push(item);
+            }
+            fulfilled(Value::Array(VmRef::new(out)))
         }
-        Some(v) => v.clone(),
-        None => Value::Null,
+        Some(v) => fulfilled(v.clone()),
+        None => fulfilled(Value::Null),
     }
 }
 
-/// Promise.race(iterable) - returns first element of array.
+/// `Promise.race(iterable)` — first element wins (blocking first promise if it is one).
 pub fn promise_race(args: &[Value]) -> Value {
     match args.first() {
-        Some(Value::Array(arr)) => arr
-            .borrow()
-            .first()
-            .cloned()
-            .unwrap_or(Value::Null),
-        _ => Value::Null,
+        Some(Value::Array(arr)) => {
+            let borrowed = arr.borrow();
+            for v in borrowed.iter() {
+                if let Value::Promise(p) = v {
+                    return match p.block_until_settled() {
+                        Ok(x) => fulfilled(x),
+                        Err(e) => rejected(e),
+                    };
+                }
+                return fulfilled(v.clone());
+            }
+            Value::Null
+        }
+        Some(v) => fulfilled(v.clone()),
+        None => Value::Null,
     }
 }
 
-/// Build the Promise object with resolve, reject, all, race static methods.
+/// Build the global `Promise` object: `__call` (constructor) + static methods.
 pub fn promise_object() -> Value {
     let mut map: ObjectMap = ObjectMap::default();
+
+    let ctor = Value::native(|args: &[Value]| match args.first() {
+        Some(Value::Function(f)) => {
+            let (tx, rx) = mpsc::channel();
+            let tx_cell = Arc::new(Mutex::new(Some(tx)));
+            let resolve = Value::native({
+                let tx_cell = Arc::clone(&tx_cell);
+                move |a: &[Value]| {
+                    if let Some(t) = tx_cell.lock().unwrap().take() {
+                        let _ = t.send(Ok(
+                            a.first().cloned().unwrap_or(Value::Null),
+                        ));
+                    }
+                    Value::Null
+                }
+            });
+            let reject = Value::native({
+                let tx_cell = Arc::clone(&tx_cell);
+                move |a: &[Value]| {
+                    if let Some(t) = tx_cell.lock().unwrap().take() {
+                        let _ = t.send(Err(
+                            a.first().cloned().unwrap_or(Value::Null),
+                        ));
+                    }
+                    Value::Null
+                }
+            });
+            let _ = f(&[resolve, reject]);
+            Value::Promise(Arc::new(DeferredChannelPromise {
+                rx: Mutex::new(Some(rx)),
+            }))
+        }
+        _ => Value::Null,
+    });
+
+    map.insert(Arc::from("__call"), ctor);
     map.insert(
         Arc::from("resolve"),
-        Value::Function(Rc::new(|args: &[Value]| promise_resolve(args))),
+        Value::native(|args: &[Value]| promise_resolve(args)),
     );
     map.insert(
         Arc::from("reject"),
-        Value::Function(Rc::new(|args: &[Value]| promise_reject(args))),
+        Value::native(|args: &[Value]| promise_reject(args)),
     );
     map.insert(
         Arc::from("all"),
-        Value::Function(Rc::new(|args: &[Value]| promise_all(args))),
+        Value::native(|args: &[Value]| promise_all(args)),
     );
     map.insert(
         Arc::from("race"),
-        Value::Function(Rc::new(|args: &[Value]| promise_race(args))),
+        Value::native(|args: &[Value]| promise_race(args)),
     );
-    Value::Object(Rc::new(RefCell::new(map)))
+    Value::Object(VmRef::new(map))
+}
+
+/// `.then(onFulfilled, onRejected)` for a `Value::Promise` instance (VM `GetMember`).
+pub fn promise_instance_then(p: &Arc<dyn TishPromise>, args: &[Value]) -> Value {
+    Value::Promise(Arc::new(ThenPromise {
+        pred: Arc::clone(p),
+        on_fulfilled: args.first().cloned(),
+        on_rejected: args.get(1).cloned(),
+    }))
+}
+
+/// `.catch(onRejected)` for a `Value::Promise` instance.
+pub fn promise_instance_catch(p: &Arc<dyn TishPromise>, args: &[Value]) -> Value {
+    Value::Promise(Arc::new(ThenPromise {
+        pred: Arc::clone(p),
+        on_fulfilled: None,
+        on_rejected: args.first().cloned(),
+    }))
 }

package/crates/tish_runtime/src/promise_io.rs

@@ -1,6 +1,7 @@
 //! Promises carrying only Send payloads (string results for text(), etc.).
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use tishlang_core::{ObjectMap, TishPromise, Value};
@@ -10,7 +11,7 @@ fn error_value(msg: String) -> Value {
     let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(msg.into()));
     obj.insert(Arc::from("ok"), Value::Bool(false));
-    Value::Object(Rc::new(RefCell::new(obj)))
+    Value::Object(VmRef::new(obj))
 }
 
 pub struct StringResultPromise {

package/crates/tish_runtime/src/timers.rs

@@ -1,4 +1,4 @@
-//! setTimeout, clearTimeout for compiled Tish and VM.
+//! setTimeout, setInterval, clearTimeout, clearInterval for compiled Tish and VM.
 //! Callbacks run when blocking ops (e.g. ws.receiveTimeout) yield in their poll loop.
 
 use std::cell::RefCell;
@@ -35,11 +35,18 @@ fn extract_num(v: Option<&Value>) -> u64 {
 
 /// Sleep for ms, running due timers before sleeping. Use this instead of thread::sleep
 /// in blocking loops so setTimeout callbacks can fire.
+#[allow(dead_code)] // Used by embedders with blocking poll loops; AppKit uses [`drain_timers`] instead.
 pub fn sleep_with_drain(ms: u64) {
     run_due_timers();
     std::thread::sleep(Duration::from_millis(ms));
 }
 
+/// Run all due timer callbacks (e.g. from an AppKit / GUI event pump).
+#[inline]
+pub fn drain_timers() {
+    run_due_timers();
+}
+
 /// Run all due timer callbacks.
 fn run_due_timers() {
     let due = take_due_timers();
@@ -109,6 +116,30 @@ pub fn set_timeout(args: &[Value]) -> Value {
     Value::Number(id as f64)
 }
 
+/// setInterval(callback, intervalMs, ...args) — first run after `intervalMs`, then repeats.
+pub fn set_interval(args: &[Value]) -> Value {
+    let callback = args.first().cloned().unwrap_or(Value::Null);
+    let interval_ms = extract_num(args.get(1)).min(3600_000);
+    let extra_args: Vec<Value> = args.iter().skip(2).cloned().collect();
+    if matches!(callback, Value::Null) {
+        return Value::Number(next_id() as f64);
+    }
+    let id = next_id();
+    let due = Instant::now() + Duration::from_millis(interval_ms);
+    REGISTRY.with(|r| {
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args: extra_args,
+                interval_ms,
+            },
+        );
+    });
+    Value::Number(id as f64)
+}
+
 /// clearTimeout(id) - removes timer.
 pub fn clear_timeout(args: &[Value]) -> Value {
     let id = args
@@ -123,3 +154,8 @@ pub fn clear_timeout(args: &[Value]) -> Value {
     });
     Value::Null
 }
+
+/// clearInterval(id) — same registry as clearTimeout.
+pub fn clear_interval(args: &[Value]) -> Value {
+    clear_timeout(args)
+}

package/crates/tish_runtime/src/ws.rs

@@ -6,6 +6,7 @@
 //! - **Broadcast** (Node pattern): `server.clients.forEach(ws => ws.send(data))` or iterate room conns and `wsSend(ws, data)` (same as `ws.send(data)`)
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
@@ -16,8 +17,8 @@ use std::time::{Duration, Instant};
 use futures_util::{SinkExt, StreamExt};
 use lazy_static::lazy_static;
 use tishlang_core::{ObjectMap, Value};
-use tokio::sync::mpsc as tokio_mpsc;
 use tokio::runtime::Runtime;
+use tokio::sync::mpsc as tokio_mpsc;
 
 thread_local! {
     /// Multi-thread runtime so `tokio::spawn` I/O tasks keep running after `block_on` returns.
@@ -199,39 +200,42 @@ fn conn_object(id: u32) -> Value {
     obj.insert(Arc::from("readyState"), Value::Number(1.0)); // OPEN
     obj.insert(
         Arc::from("send"),
-        Value::Function(Rc::new(move |args: &[Value]| {
-            let data = args.first().map(|v| v.to_display_string()).unwrap_or_default();
+        Value::native(move |args: &[Value]| {
+            let data = args
+                .first()
+                .map(|v| v.to_display_string())
+                .unwrap_or_default();
             Value::Bool(conn_send(id, data))
-        })),
+        }),
     );
     obj.insert(
         Arc::from("close"),
-        Value::Function(Rc::new(move |_args: &[Value]| {
+        Value::native(move |_args: &[Value]| {
             unregister(id);
             Value::Null
-        })),
+        }),
     );
     obj.insert(
         Arc::from("receive"),
-        Value::Function(Rc::new(move |_args: &[Value]| {
-            match conn_receive(id) {
-                Some(s) => {
-                    let mut ev: ObjectMap = ObjectMap::default();
-                    ev.insert(Arc::from("data"), Value::String(s.into()));
-                    Value::Object(Rc::new(RefCell::new(ev)))
-                }
-                None => Value::Null,
+        Value::native(move |_args: &[Value]| match conn_receive(id) {
+            Some(s) => {
+                let mut ev: ObjectMap = ObjectMap::default();
+                ev.insert(Arc::from("data"), Value::String(s.into()));
+                Value::Object(VmRef::new(ev))
             }
-        })),
+            None => Value::Null,
+        }),
     );
     let id_timeout = id;
     obj.insert(
         Arc::from("receiveTimeout"),
-        Value::Function(Rc::new(move |args: &[Value]| {
+        Value::native(move |args: &[Value]| {
             let timeout_ms = args
                 .first()
                 .and_then(|v| match v {
-                    Value::Number(n) if n.is_finite() && *n >= 0.0 => Some((*n as u64).min(3600_000)),
+                    Value::Number(n) if n.is_finite() && *n >= 0.0 => {
+                        Some((*n as u64).min(3600_000))
+                    }
                     _ => None,
                 })
                 .unwrap_or(1000);
@@ -239,13 +243,13 @@ fn conn_object(id: u32) -> Value {
                 Some(s) => {
                     let mut ev: ObjectMap = ObjectMap::default();
                     ev.insert(Arc::from("data"), Value::String(s.into()));
-                    Value::Object(Rc::new(RefCell::new(ev)))
+                    Value::Object(VmRef::new(ev))
                 }
                 None => Value::Null,
             }
-        })),
+        }),
     );
-    Value::Object(Rc::new(RefCell::new(obj)))
+    Value::Object(VmRef::new(obj))
 }
 
 fn parse_port(args: &[Value]) -> Option<u16> {
@@ -366,11 +370,17 @@ pub fn web_socket_server_listen(args: &[Value]) -> Value {
                 };
                 let ws_stream = match tokio_tungstenite::accept_async(stream).await {
                     Ok(ws) => {
-                        eprintln!("[tish ws] server accepted connection (handshake OK): port {}", port);
+                        eprintln!(
+                            "[tish ws] server accepted connection (handshake OK): port {}",
+                            port
+                        );
                         ws
                     }
                     Err(e) => {
-                        eprintln!("[tish ws] server accept_async failed: {} (port {})", e, port);
+                        eprintln!(
+                            "[tish ws] server accept_async failed: {} (port {})",
+                            e, port
+                        );
                         continue;
                     }
                 };
@@ -463,9 +473,9 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
     }
 
     // Node.js-compatible: server.clients is array of connected WebSocket instances
-    let clients: Rc<RefCell<Vec<Value>>> = Rc::new(RefCell::new(Vec::new()));
+    let clients: VmRef<Vec<Value>> = VmRef::new(Vec::new());
 
-    let on_fn = Rc::new(|args: &[Value]| {
+    let on_fn = Value::native(|args: &[Value]| {
         let Some(Value::Object(so)) = args.first() else {
             return Value::Null;
         };
@@ -475,14 +485,13 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
             .unwrap_or_default();
         let cb = args.get(2).cloned().unwrap_or(Value::Null);
         if event == "connection" {
-            so.borrow_mut()
-                .insert(Arc::from("_onConnection"), cb);
+            so.borrow_mut().insert(Arc::from("_onConnection"), cb);
         }
         Value::Null
     });
 
-    let clients_listen = Rc::clone(&clients);
-    let listen_fn = Rc::new(move |args: &[Value]| {
+    let clients_listen = clients.clone();
+    let listen_fn = Value::native(move |args: &[Value]| {
         let Some(Value::Object(so)) = args.first() else {
             return Value::Null;
         };
@@ -511,8 +520,8 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
         Value::Null
     });
 
-    let clients_accept = Rc::clone(&clients);
-    let accept_timeout_fn = Rc::new(move |args: &[Value]| {
+    let clients_accept = clients.clone();
+    let accept_timeout_fn = Value::native(move |args: &[Value]| {
         let Some(Value::Object(so)) = args.first() else {
             return Value::Null;
         };
@@ -533,10 +542,10 @@ pub fn web_socket_server_construct(args: &[Value]) -> Value {
     m.insert(Arc::from("_handle"), handle_val);
     m.insert(Arc::from("_onConnection"), Value::Null);
     m.insert(Arc::from("clients"), Value::Array(clients));
-    m.insert(Arc::from("on"), Value::Function(on_fn));
-    m.insert(Arc::from("listen"), Value::Function(listen_fn));
-    m.insert(Arc::from("acceptTimeout"), Value::Function(accept_timeout_fn));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from("on"), on_fn);
+    m.insert(Arc::from("listen"), listen_fn);
+    m.insert(Arc::from("acceptTimeout"), accept_timeout_fn);
+    Value::Object(VmRef::new(m))
 }
 
 #[cfg(test)]
@@ -551,7 +560,7 @@ mod tests {
         let opts = {
             let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
-            Value::Object(Rc::new(RefCell::new(m)))
+            Value::Object(VmRef::new(m))
         };
 
         let handle = match web_socket_server_listen(std::slice::from_ref(&opts)) {
@@ -578,7 +587,9 @@ mod tests {
                                 .unwrap_or_default(),
                             _ => String::new(),
                         };
-                        if let Some(Value::Function(sf)) = wso.borrow().get(&Arc::from("send")).cloned() {
+                        if let Some(Value::Function(sf)) =
+                            wso.borrow().get(&Arc::from("send")).cloned()
+                        {
                             let _ = sf(&[Value::String(data.into())]);
                         }
                         break;
@@ -634,7 +645,7 @@ mod tests {
         let opts = {
             let mut m: ObjectMap = ObjectMap::default();
             m.insert(Arc::from("port"), Value::Number(port as f64));
-            Value::Object(Rc::new(RefCell::new(m)))
+            Value::Object(VmRef::new(m))
         };
 
         let handle = match web_socket_server_listen(std::slice::from_ref(&opts)) {
@@ -666,8 +677,8 @@ mod tests {
                     if data.contains("\"type\":\"join\"") || data.contains("\"type\": \"join\"") {
                         let joined = r#"{"type":"joined","sessionId":"default"}"#;
                         let presence = r#"{"type":"presence","agentLanes":["ai-a"]}"#;
-                        ws_send_native(&Value::Object(Rc::clone(&wso)), joined);
-                        ws_send_native(&Value::Object(Rc::clone(&wso)), presence);
+                        ws_send_native(&Value::Object(wso.clone()), joined);
+                        ws_send_native(&Value::Object(wso.clone()), presence);
                         return;
                     }
                 }
@@ -692,7 +703,11 @@ mod tests {
         let _ = send_f(&[Value::String(join_msg.into())]);
 
         // Client uses receiveTimeout like the agent
-        let recv_timeout = co.borrow().get(&Arc::from("receiveTimeout")).cloned().unwrap();
+        let recv_timeout = co
+            .borrow()
+            .get(&Arc::from("receiveTimeout"))
+            .cloned()
+            .unwrap();
         let Value::Function(recv_timeout_f) = recv_timeout else {
             panic!("no receiveTimeout");
         };
@@ -707,7 +722,11 @@ mod tests {
             .get(&Arc::from("data"))
             .map(|v| v.to_display_string())
             .unwrap_or_default();
-        assert!(data1.contains("\"type\":\"joined\""), "expected joined, got {}", data1);
+        assert!(
+            data1.contains("\"type\":\"joined\""),
+            "expected joined, got {}",
+            data1
+        );
 
         let got2 = recv_timeout_f(&[timeout_arg]);
         let Value::Object(ev2) = got2 else {
@@ -718,7 +737,11 @@ mod tests {
             .get(&Arc::from("data"))
             .map(|v| v.to_display_string())
             .unwrap_or_default();
-        assert!(data2.contains("\"type\":\"presence\""), "expected presence, got {}", data2);
+        assert!(
+            data2.contains("\"type\":\"presence\""),
+            "expected presence, got {}",
+            data2
+        );
 
         let _ = server.join();
     }

package/crates/tish_runtime/tests/fetch_readable_stream.rs

@@ -51,16 +51,17 @@ fn fetch_readable_stream_read_chunks() {
         Value::Object(o) => o.borrow(),
         _ => panic!("expected object response, got {:?}", resp),
     };
-    assert!(obj.get(&std::sync::Arc::from("ok")).map(|v| matches!(v, Value::Bool(true))).unwrap_or(false));
+    assert!(obj
+        .get(&std::sync::Arc::from("ok"))
+        .map(|v| matches!(v, Value::Bool(true)))
+        .unwrap_or(false));
 
     let body = obj.get(&std::sync::Arc::from("body")).expect("body");
     let stream = match body {
         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")(&[]);
     let reader = match reader_val {
         Value::Opaque(r) => r,
         _ => panic!("expected reader opaque, got {:?}", reader_val),