@tishlang/tish 1.9.2 → 1.12.0

package/crates/tish_resolve/src/pos.rs

@@ -104,7 +104,12 @@ pub fn byte_offset_to_lsp(source: &str, byte: usize) -> Option<(u32, u32)> {
 }
 
 /// True if LSP position lies inside `span` (half-open in byte space).
-pub fn span_contains_lsp_position(source: &str, span: &Span, lsp_line: u32, lsp_character: u32) -> bool {
+pub fn span_contains_lsp_position(
+    source: &str,
+    span: &Span,
+    lsp_line: u32,
+    lsp_character: u32,
+) -> bool {
     let Some(b) = lsp_position_to_byte_offset(source, lsp_line, lsp_character) else {
         return false;
     };
@@ -117,7 +122,10 @@ pub fn span_contains_lsp_position(source: &str, span: &Span, lsp_line: u32, lsp_
 /// LSP start (inclusive) and end (exclusive) positions for a lexer span.
 pub fn span_to_lsp_range_exclusive(source: &str, span: &Span) -> Option<((u32, u32), (u32, u32))> {
     let (lo, hi) = lex_span_byte_range(source, span)?;
-    Some((byte_offset_to_lsp(source, lo)?, byte_offset_to_lsp(source, hi)?))
+    Some((
+        byte_offset_to_lsp(source, lo)?,
+        byte_offset_to_lsp(source, hi)?,
+    ))
 }
 
 #[cfg(test)]

package/crates/tish_runtime/Cargo.toml

@@ -31,6 +31,9 @@ send-values = [
     "tishlang_core/send-values",
     "tishlang_builtins/send-values",
 ]
+# Promise / `await` on settled values only (no `fetch` / HTTP stack). Used for WASI and other
+# targets where the full `http` feature does not compile.
+promise = ["send-values"]
 # Phase-3 item 13: io_uring-backed accept + send loop (Linux only).
 # Disabled by default; enable with `--feature http,http-io-uring` on Linux
 # to pick up the experimental accept path.

package/crates/tish_runtime/src/http.rs

@@ -10,8 +10,8 @@
 //! gets its own tiny_http connection pool but the accept queue is shared at
 //! the kernel level.
 //!
-//! The Tish handler closure captures `Value::Function(Rc<…>)` which is
-//! `!Send`, so handler execution stays on the VM (caller) thread:
+//! Without `send-values`, the handler captures `Value::Function` backed by
+//! `Rc` and is `!Send`, so handler execution stays on a single VM thread:
 //!
 //! ```text
 //!   worker 0 ──┐
@@ -24,14 +24,15 @@
 //! threaded VM guarantee. Cached `Date:` header + shared `Arc<str>` response
 //! bodies round out the hot-path optimisations.
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
-use std::collections::VecDeque;
 use std::fs::File;
 use std::io::Write;
-use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::{mpsc, Arc, Mutex, OnceLock};
+use std::sync::{Arc, OnceLock};
+
+#[cfg(not(feature = "send-values"))]
+use std::collections::VecDeque;
+#[cfg(not(feature = "send-values"))]
+use std::sync::mpsc;
 use std::thread;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
@@ -64,17 +65,17 @@ where
 }
 
 pub fn await_fetch(args: Vec<Value>) -> Value {
-    crate::native_promise::await_promise(crate::native_promise::fetch_promise(args))
+    crate::promise::await_promise(crate::native_promise::fetch_promise(args))
 }
 
 pub fn await_fetch_all(args: Vec<Value>) -> Value {
-    crate::native_promise::await_promise(crate::native_promise::fetch_all_promise(args))
+    crate::promise::await_promise(crate::native_promise::fetch_all_promise(args))
 }
 
 pub(crate) fn extract_method(options: Option<&Value>) -> String {
     options
         .and_then(|v| match v {
-            Value::Object(obj) => obj.borrow().get(&Arc::from("method")).cloned(),
+            Value::Object(obj) => obj.borrow().strings.get("method").cloned(),
             _ => None,
         })
         .map(|v| v.to_display_string().to_uppercase())
@@ -84,12 +85,13 @@ pub(crate) fn extract_method(options: Option<&Value>) -> String {
 pub(crate) fn extract_headers(options: Option<&Value>) -> Vec<(String, String)> {
     options
         .and_then(|v| match v {
-            Value::Object(obj) => obj.borrow().get(&Arc::from("headers")).cloned(),
+            Value::Object(obj) => obj.borrow().strings.get("headers").cloned(),
             _ => None,
         })
         .map(|v| match v {
             Value::Object(obj) => obj
                 .borrow()
+                .strings
                 .iter()
                 .map(|(k, v)| (k.to_string(), v.to_display_string()))
                 .collect(),
@@ -102,7 +104,8 @@ pub(crate) fn extract_body(options: Option<&Value>) -> Option<String> {
     options.and_then(|v| match v {
         Value::Object(obj) => obj
             .borrow()
-            .get(&Arc::from("body"))
+            .strings
+            .get("body")
             .map(|v| v.to_display_string()),
         _ => None,
     })
@@ -112,7 +115,7 @@ pub(crate) fn build_error_response(error: &str) -> Value {
     let mut obj: ObjectMap = ObjectMap::with_capacity(2);
     obj.insert(Arc::from("error"), Value::String(error.into()));
     obj.insert(Arc::from("ok"), Value::Bool(false));
-    Value::Object(VmRef::new(obj))
+    Value::object(obj)
 }
 
 // -------- cached Date header -----------------------------------------------
@@ -194,12 +197,6 @@ pub fn cached_date_header_arc() -> Arc<String> {
     ensure_date_thread().load_full()
 }
 
-/// Back-compat String flavour (allocates). New hot-path code should use
-/// `cached_date_header_arc`.
-pub fn cached_date_header() -> String {
-    cached_date_header_arc().as_str().to_string()
-}
-
 // -------- Send-safe request/response primitives ----------------------------
 
 #[derive(Debug, Clone)]
@@ -270,10 +267,10 @@ impl RequestPrimitive {
             }
             obj.insert(
                 Arc::clone(&keys.headers),
-                Value::Object(VmRef::new(h)),
+                Value::object(h),
             );
             obj.insert(Arc::clone(&keys.body), Value::String(self.body.into()));
-            Value::Object(VmRef::new(obj))
+            Value::object(obj)
         })
     }
 }
@@ -331,16 +328,17 @@ impl ResponsePrimitive {
                 let obj_ref = obj.borrow();
 
                 let status = obj_ref
-                    .get(&Arc::from("status"))
+                    .strings
+                    .get("status")
                     .and_then(|v| match v {
                         Value::Number(n) => Some(*n as u16),
                         _ => None,
                     })
                     .unwrap_or(default_status);
 
-                let has_error = obj_ref.contains_key(&Arc::from("error"));
+                let has_error = obj_ref.strings.contains_key("error");
 
-                let body: ResponseBody = if let Some(bb) = obj_ref.get(&Arc::from("bodyBytes")) {
+                let body: ResponseBody = if let Some(bb) = obj_ref.strings.get("bodyBytes") {
                     match bb {
                         Value::Array(a) => {
                             let v: Vec<u8> = a
@@ -355,9 +353,9 @@ impl ResponsePrimitive {
                         }
                         _ => ResponseBody::Text(Arc::from(bb.to_display_string())),
                     }
-                } else if let Some(b) = obj_ref.get(&Arc::from("body")) {
+                } else if let Some(b) = obj_ref.strings.get("body") {
                     match b {
-                        Value::String(s) => ResponseBody::Text(Arc::clone(s)),
+                        Value::String(s) => ResponseBody::Text(Arc::clone(&s)),
                         Value::Array(a) => {
                             let borrow = a.borrow();
                             if !borrow.is_empty()
@@ -381,7 +379,8 @@ impl ResponsePrimitive {
                 } else if has_error {
                     ResponseBody::Text(Arc::from(
                         obj_ref
-                            .get(&Arc::from("error"))
+                            .strings
+                            .get("error")
                             .map(|v| v.to_display_string())
                             .unwrap_or_default(),
                     ))
@@ -396,10 +395,12 @@ impl ResponsePrimitive {
                 };
 
                 let headers = obj_ref
-                    .get(&Arc::from("headers"))
+                    .strings
+                    .get("headers")
                     .and_then(|v| match v {
                         Value::Object(h) => Some(
                             h.borrow()
+                                .strings
                                 .iter()
                                 .map(|(k, v)| (k.to_string(), v.to_display_string()))
                                 .collect(),
@@ -451,22 +452,25 @@ fn extract_file_from_response(value: &Value) -> Option<(u16, Vec<(String, String
         return None;
     };
     let obj_ref = obj.borrow();
-    let Value::String(file_path) = obj_ref.get(&Arc::from("file"))? else {
+    let Value::String(file_path) = obj_ref.strings.get("file")? else {
         return None;
     };
     let file_path = file_path.to_string();
     let status = obj_ref
-        .get(&Arc::from("status"))
+        .strings
+        .get("status")
         .and_then(|v| match v {
             Value::Number(n) => Some(*n as u16),
             _ => None,
         })
         .unwrap_or(200);
     let headers = obj_ref
-        .get(&Arc::from("headers"))
+        .strings
+        .get("headers")
         .and_then(|v| match v {
             Value::Object(h) => Some(
                 h.borrow()
+                    .strings
                     .iter()
                     .map(|(k, v)| (k.to_string(), v.to_display_string()))
                     .collect(),
@@ -770,8 +774,6 @@ pub(crate) fn num_prefork_workers() -> usize {
 
 // -------- serve() ----------------------------------------------------------
 
-type Job = (RequestPrimitive, mpsc::SyncSender<ResponsePrimitive>);
-
 /// Start an HTTP server that handles requests using the provided handler function.
 ///
 /// When `send-values` is enabled (required for the `http` feature) the
@@ -995,6 +997,9 @@ fn serve_impl_with_factory(
     Value::Null
 }
 
+#[cfg(not(feature = "send-values"))]
+type Job = (RequestPrimitive, mpsc::SyncSender<ResponsePrimitive>);
+
 #[cfg(not(feature = "send-values"))]
 fn serve_impl<F>(args: &[Value], handler: F) -> Value
 where
@@ -1130,6 +1135,7 @@ fn worker_loop_direct(
     }
 }
 
+#[cfg(not(feature = "send-values"))]
 fn worker_loop(
     listener: std::net::TcpListener,
     dispatch: mpsc::SyncSender<Job>,
@@ -1202,12 +1208,6 @@ fn worker_loop(
     }
 }
 
-#[allow(dead_code)]
-pub fn create_server(port: u16) -> Result<tiny_http::Server, String> {
-    let addr = format!("0.0.0.0:{}", port);
-    tiny_http::Server::http(&addr).map_err(|e| format!("Failed to start server: {}", e))
-}
-
 // -------- public shims for alternate HTTP backends ------------------------
 //
 // Exposed so `http_hyper.rs` (and any future backend) can reuse the same

package/crates/tish_runtime/src/http_fetch.rs

@@ -1,11 +1,10 @@
 //! Web Fetch–aligned Response, ReadableStream, reader.read(), text()/json().
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
 use std::pin::Pin;
-use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
+use tishlang_core::VmRef;
+
 use bytes::Bytes;
 use futures::Stream;
 use futures::StreamExt;
@@ -87,19 +86,19 @@ impl TishPromise for ReadChunkPromise {
                     let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(true));
                     o.insert(Arc::from("value"), Value::Null);
-                    Ok(Value::Object(VmRef::new(o)))
+                    Ok(Value::object(o))
                 }
                 Ok(Ok(ReadChunk::Bytes(b))) => {
                     let arr: Vec<Value> = b.iter().map(|u| Value::Number(*u as f64)).collect();
                     let mut o = ObjectMap::default();
                     o.insert(Arc::from("done"), Value::Bool(false));
                     o.insert(Arc::from("value"), Value::Array(VmRef::new(arr)));
-                    Ok(Value::Object(VmRef::new(o)))
+                    Ok(Value::object(o))
                 }
                 Ok(Err(e)) => Err({
                     let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
-                    Value::Object(VmRef::new(obj))
+                    Value::object(obj)
                 }),
                 Err(_) => Err(Value::String("Promise dropped".into())),
             }
@@ -124,13 +123,13 @@ impl TishPromise for JsonTextPromise {
                     Err(e) => Err({
                         let mut obj = ObjectMap::default();
                         obj.insert(Arc::from("error"), Value::String(e.into()));
-                        Value::Object(VmRef::new(obj))
+                        Value::object(obj)
                     }),
                 },
                 Ok(Err(e)) => Err({
                     let mut obj = ObjectMap::default();
                     obj.insert(Arc::from("error"), Value::String(e.into()));
-                    Value::Object(VmRef::new(obj))
+                    Value::object(obj)
                 }),
                 Err(_) => Err(Value::String("Promise dropped".into())),
             }
@@ -241,7 +240,7 @@ impl TishOpaque for HttpReadableStream {
             Err(e) => {
                 let mut m = ObjectMap::default();
                 m.insert(Arc::from("error"), Value::String(e.into()));
-                Value::Object(VmRef::new(m))
+                Value::object(m)
             }
         }))
     }
@@ -306,7 +305,7 @@ fn headers_to_value(headers: &reqwest::header::HeaderMap) -> Value {
             headers_obj.insert(Arc::from(key.as_str()), Value::String(v.into()));
         }
     }
-    Value::Object(VmRef::new(headers_obj))
+    Value::object(headers_obj)
 }
 
 pub fn response_value_from_reqwest(response: reqwest::Response) -> Value {
@@ -351,7 +350,7 @@ pub fn response_value_from_reqwest(response: reqwest::Response) -> Value {
     obj.insert(Arc::from("body"), body_stream_val);
     obj.insert(Arc::from("text"), Value::Function(text_fn));
     obj.insert(Arc::from("json"), Value::Function(json_fn));
-    Value::Object(VmRef::new(obj))
+    Value::object(obj)
 }
 
 async fn send_request_parts(
@@ -424,7 +423,8 @@ pub fn fetch_all_promise_from_args(args: Vec<Value>) -> Value {
             Value::Object(obj) => {
                 let obj_ref = obj.borrow();
                 match obj_ref
-                    .get(&Arc::from("url"))
+                    .strings
+                    .get("url")
                     .map(|v| v.to_display_string())
                 {
                     Some(u) => (u, Some(req.clone())),

package/crates/tish_runtime/src/lib.rs

@@ -3,18 +3,17 @@
 //! Re-exports core types from tishlang_core and provides console, Math,
 //! and other builtin functions for compiled Tish programs.
 
-#[cfg(feature = "regex")]
-use std::cell::RefCell;
 use std::fmt;
-#[cfg(feature = "regex")]
-use std::rc::Rc;
 use std::sync::OnceLock;
 use tishlang_builtins::helpers::extract_num;
 #[cfg(feature = "fs")]
 use tishlang_builtins::helpers::make_error_value;
 
+pub use tishlang_builtins::symbol::symbol_object;
 pub use tishlang_core::ObjectMap;
 pub use tishlang_core::Value;
+/// Used by native codegen for `f()` / `obj()` dispatch (`Value::Function` or `__call` on objects).
+pub use tishlang_core::value_call;
 // Re-export the shared-mutable wrapper so the Rust code emitted by
 // `tishlang_compile::codegen` can write `VmRef::new(...)` without needing
 // a direct dependency on `tishlang_core` from the generated crate.
@@ -48,7 +47,8 @@ pub use tishlang_builtins::string::{
     pad_start as string_pad_start_impl, repeat as string_repeat_impl,
     replace as string_replace_impl, replace_all as string_replace_all_impl,
     slice as string_slice_impl, split as string_split_impl,
-    starts_with as string_starts_with_impl, substring as string_substring_impl,
+    starts_with as string_starts_with_impl, substr as string_substr_impl,
+    substring as string_substring_impl,
     to_lower_case as string_to_lower_case, to_upper_case as string_to_upper_case,
     trim as string_trim,
 };
@@ -106,6 +106,9 @@ pub fn string_slice(s: &Value, start: &Value, end: &Value) -> Value {
 pub fn string_substring(s: &Value, start: &Value, end: &Value) -> Value {
     string_substring_impl(s, start, end)
 }
+pub fn string_substr(s: &Value, start: &Value, length: &Value) -> Value {
+    string_substr_impl(s, start, length)
+}
 pub fn string_split(s: &Value, sep: &Value) -> Value {
     string_split_impl(s, sep)
 }
@@ -421,6 +424,7 @@ pub use tishlang_builtins::math::{
     exp as tish_math_exp_impl, floor as tish_math_floor_impl, max as tish_math_max_impl,
     min as tish_math_min_impl, pow as tish_math_pow_impl, random as tish_math_random_impl,
     round as tish_math_round_impl, sign as tish_math_sign_impl, sin as tish_math_sin_impl,
+    imul as tish_math_imul_impl,
     sqrt as tish_math_sqrt_impl, tan as tish_math_tan_impl, trunc as tish_math_trunc_impl,
 };
 
@@ -461,6 +465,9 @@ pub fn math_exp(args: &[Value]) -> Value {
 pub fn math_trunc(args: &[Value]) -> Value {
     tish_math_trunc_impl(args)
 }
+pub fn math_imul(args: &[Value]) -> Value {
+    tish_math_imul_impl(args)
+}
 pub fn math_pow(args: &[Value]) -> Value {
     tish_math_pow_impl(args)
 }
@@ -590,8 +597,6 @@ pub fn is_dir(args: &[Value]) -> Value {
 
 #[cfg(feature = "fs")]
 pub fn read_dir(args: &[Value]) -> Value {
-    use std::cell::RefCell;
-    use std::rc::Rc;
     let path = args
         .first()
         .map(|v| v.to_display_string())
@@ -632,7 +637,7 @@ pub fn get_prop(obj: &Value, key: impl AsRef<str>) -> Value {
             // directly. Previously we allocated a fresh `Arc<str>` on
             // every call (one heap alloc per `r.field` read in tight
             // handler loops); this version is alloc-free on the hit path.
-            map.borrow().get(key).cloned().unwrap_or(Value::Null)
+            map.borrow().strings.get(key).cloned().unwrap_or(Value::Null)
         }
         Value::Array(arr) => {
             if key == "length" {
@@ -685,14 +690,7 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
             };
             arr.borrow().get(idx).cloned().unwrap_or(Value::Null)
         }
-        Value::Object(map) => {
-            let key: Arc<str> = match index {
-                Value::Number(n) => n.to_string().into(),
-                Value::String(s) => Arc::clone(s),
-                _ => return Value::Null,
-            };
-            map.borrow().get(&key).cloned().unwrap_or(Value::Null)
-        }
+        Value::Object(_) => tishlang_core::object_get(obj, index).unwrap_or(Value::Null),
         _ => Value::Null,
     }
 }
@@ -705,10 +703,10 @@ pub fn set_prop(obj: &Value, key: &str, val: Value) -> Value {
             // exists we re-use the existing `Arc<str>` and skip the
             // alloc. Only newly-inserted keys pay for `Arc::from(key)`.
             let mut m = map.borrow_mut();
-            if let Some(slot) = m.get_mut(key) {
+            if let Some(slot) = m.strings.get_mut(key) {
                 *slot = val.clone();
             } else {
-                m.insert(Arc::from(key), val.clone());
+                m.strings.insert(Arc::from(key), val.clone());
             }
             val
         }
@@ -731,13 +729,8 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
             arr_mut[index] = val.clone();
             val
         }
-        Value::Object(map) => {
-            let key: Arc<str> = match idx {
-                Value::Number(n) => n.to_string().into(),
-                Value::String(s) => Arc::clone(s),
-                _ => panic!("Object key must be string or number"),
-            };
-            map.borrow_mut().insert(key, val.clone());
+        Value::Object(_) => {
+            tishlang_core::object_set(obj, idx, val.clone()).expect("object set");
             val
         }
         _ => panic!("Cannot index assign on non-array/object"),
@@ -745,26 +738,24 @@ pub fn set_index(obj: &Value, idx: &Value, val: Value) -> Value {
 }
 
 pub fn in_operator(key: &Value, obj: &Value) -> Value {
-    let key_str: Arc<str> = match key {
-        Value::String(s) => Arc::clone(s),
-        Value::Number(n) => n.to_string().into(),
-        _ => return Value::Bool(false),
-    };
-
-    let result = match obj {
-        Value::Object(map) => map.borrow().contains_key(&key_str),
+    match obj {
+        Value::Object(_) => Value::Bool(tishlang_core::object_has(obj, key)),
         Value::Array(arr) => {
-            key_str.as_ref() == "length"
+            let key_str: Arc<str> = match key {
+                Value::String(s) => Arc::clone(s),
+                Value::Number(n) => n.to_string().into(),
+                _ => return Value::Bool(false),
+            };
+            let result = key_str.as_ref() == "length"
                 || key_str
                     .parse::<usize>()
                     .ok()
                     .map(|i| i < arr.borrow().len())
-                    .unwrap_or(false)
+                    .unwrap_or(false);
+            Value::Bool(result)
         }
-        _ => false,
-    };
-
-    Value::Bool(result)
+        _ => Value::Bool(false),
+    }
 }
 
 // Object functions - delegate to tishlang_builtins::globals
@@ -809,7 +800,7 @@ mod http_fetch;
 
 mod timers;
 
-#[cfg(feature = "http")]
+#[cfg(any(feature = "http", feature = "promise"))]
 mod promise;
 
 #[cfg(feature = "http")]
@@ -893,11 +884,11 @@ pub use timers::{
     set_interval as timer_set_interval, set_timeout as timer_set_timeout,
 };
 
-#[cfg(feature = "http")]
-pub use promise::{promise_instance_catch, promise_instance_then, promise_object};
+#[cfg(any(feature = "http", feature = "promise"))]
+pub use promise::{await_promise, promise_instance_catch, promise_instance_then, promise_object};
 
 #[cfg(feature = "http")]
-pub use native_promise::{await_promise, fetch_all_promise, fetch_async_promise, fetch_promise};
+pub use native_promise::{fetch_all_promise, fetch_async_promise, fetch_promise};
 
 // RegExp Support
 #[cfg(feature = "regex")]
@@ -999,7 +990,7 @@ fn regexp_exec_impl(re: &mut tishlang_core::TishRegExp, input: &str) -> Value {
                 };
             }
 
-            Value::Object(VmRef::new(obj))
+            Value::object(obj)
         }
         Ok(None) | Err(_) => {
             if re.flags.global || re.flags.sticky {

package/crates/tish_runtime/src/native_promise.rs

@@ -13,14 +13,3 @@ pub fn fetch_all_promise(args: Vec<Value>) -> Value {
 pub fn fetch_async_promise(args: Vec<Value>) -> Value {
     fetch_promise(args)
 }
-
-pub fn await_promise(v: Value) -> Value {
-    if let Value::Promise(p) = v {
-        match p.block_until_settled() {
-            Ok(val) => val,
-            Err(rejection) => rejection,
-        }
-    } else {
-        v
-    }
-}

package/crates/tish_runtime/src/promise.rs

@@ -213,7 +213,7 @@ pub fn promise_object() -> Value {
         Arc::from("race"),
         Value::native(|args: &[Value]| promise_race(args)),
     );
-    Value::Object(VmRef::new(map))
+    Value::object(map)
 }
 
 /// `.then(onFulfilled, onRejected)` for a `Value::Promise` instance (VM `GetMember`).
@@ -233,3 +233,16 @@ pub fn promise_instance_catch(p: &Arc<dyn TishPromise>, args: &[Value]) -> Value
         on_rejected: args.first().cloned(),
     }))
 }
+
+/// Unwrap a settled [`Value::Promise`], or pass non-promise values through (VM `AwaitPromise` /
+/// `tish:http.await`). Fetch promises still require the `http` feature.
+pub fn await_promise(v: Value) -> Value {
+    if let Value::Promise(p) = v {
+        match p.block_until_settled() {
+            Ok(val) => val,
+            Err(rejection) => rejection,
+        }
+    } else {
+        v
+    }
+}

package/crates/tish_runtime/src/promise_io.rs

@@ -1,8 +1,5 @@
 //! 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};
 use tokio::sync::oneshot;
@@ -11,7 +8,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(VmRef::new(obj))
+    Value::object(obj)
 }
 
 pub struct StringResultPromise {

package/crates/tish_runtime/src/timers.rs

@@ -47,15 +47,20 @@ pub fn drain_timers() {
     run_due_timers();
 }
 
-/// Run all due timer callbacks.
+/// Run all due timer callbacks (including timers scheduled by other timers).
 fn run_due_timers() {
-    let due = take_due_timers();
-    for (id, callback, args, interval_ms) in due {
-        if let Value::Function(f) = &callback {
-            let _ = f(&args);
+    for _ in 0..64 {
+        let due = take_due_timers();
+        if due.is_empty() {
+            break;
         }
-        if interval_ms > 0 {
-            re_register_interval(id, callback, args, interval_ms);
+        for (id, callback, args, interval_ms) in due {
+            if let Value::Function(f) = &callback {
+                let _ = f(&args);
+            }
+            if interval_ms > 0 {
+                re_register_interval(id, callback, args, interval_ms);
+            }
         }
     }
 }