@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_core/src/lib.rs

@@ -8,8 +8,10 @@ mod json;
 mod macros;
 mod uri;
 mod value;
+mod vmref;
 
 pub use console_style::{format_value_styled, format_values_for_console, use_console_colors};
-pub use value::*;
-pub use json::{json_parse, json_stringify};
+pub use json::{json_parse, json_stringify, json_stringify_into};
 pub use uri::{percent_decode, percent_encode};
+pub use value::*;
+pub use vmref::{VmReadGuard, VmRef, VmWriteGuard};

package/crates/tish_core/src/macros.rs

@@ -23,14 +23,14 @@
 #[macro_export]
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
-        use std::cell::RefCell;
-        use std::rc::Rc;
         use std::sync::Arc;
-        use $crate::{ObjectMap, Value};
+        use $crate::{ObjectMap, Value, VmRef};
         let mut map = ObjectMap::default();
         $(
-            map.insert(Arc::from($name), Value::Function(Rc::new($fn)));
+            // `Value::native` picks the right Rc / Arc wrapper depending on
+            // whether the `send-values` feature is enabled upstream.
+            map.insert(Arc::from($name), Value::native($fn));
         )*
-        Value::Object(Rc::new(RefCell::new(map)))
+        Value::Object(VmRef::new(map))
     }};
 }

package/crates/tish_core/src/uri.rs

@@ -10,13 +10,13 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
         "%2F", "%2f", // /
         "%3F", "%3f", // ?
         "%3A", "%3a", // :
-        "%40",        // @
-        "%26",        // &
+        "%40", // @
+        "%26", // &
         "%3D", "%3d", // =
         "%2B", "%2b", // +
-        "%24",        // $
+        "%24", // $
         "%2C", "%2c", // ,
-        "%23",        // #
+        "%23", // #
     ];
 
     let mut result = String::with_capacity(input.len());
@@ -46,11 +46,14 @@ pub fn percent_decode(input: &str) -> Result<String, String> {
                     None => return Err("URIError: malformed URI sequence".to_string()),
                 }
             }
-            
+
             if hex.len() == 2 {
                 let encoded = format!("%{}", hex);
                 // Check if this is a reserved character that should NOT be decoded
-                if RESERVED_ENCODED.iter().any(|r| r.eq_ignore_ascii_case(&encoded)) {
+                if RESERVED_ENCODED
+                    .iter()
+                    .any(|r| r.eq_ignore_ascii_case(&encoded))
+                {
                     result.push_str(&encoded);
                 } else if let Ok(byte) = u8::from_str_radix(&hex, 16) {
                     result.push(byte as char);

package/crates/tish_core/src/value.rs

@@ -1,11 +1,11 @@
 //! Unified Value type for Tish runtime values.
 
-use std::cell::RefCell;
-use std::rc::Rc;
 use std::sync::Arc;
 
 use ahash::AHashMap;
 
+use crate::vmref::VmRef;
+
 /// Property map for objects and other `Arc<str>` → `Value` tables (VM globals, scopes).
 /// Uses a faster hasher than `std::collections::HashMap` for string-heavy workloads.
 pub type ObjectMap = AHashMap<Arc<str>, Value>;
@@ -14,8 +14,17 @@ pub type ObjectMap = AHashMap<Arc<str>, Value>;
 use fancy_regex::Regex;
 
 /// Native function signature.
-/// Returns Value directly (not Result) for simplicity and backward compatibility.
-pub type NativeFn = Rc<dyn Fn(&[Value]) -> Value>;
+///
+/// When the `send-values` feature is enabled this is
+/// `Arc<dyn Fn + Send + Sync>`, so handler closures can be dispatched across
+/// HTTP worker threads (`tishlang_runtime::http::serve`). Otherwise it stays
+/// `Rc<dyn Fn>` for zero-overhead single-threaded execution (wasm / wasi /
+/// interpreter / cranelift / llvm VMs and any Rust native build without
+/// `http`).
+#[cfg(feature = "send-values")]
+pub type NativeFn = Arc<dyn Fn(&[Value]) -> Value + Send + Sync>;
+#[cfg(not(feature = "send-values"))]
+pub type NativeFn = std::rc::Rc<dyn Fn(&[Value]) -> Value>;
 
 /// Trait for opaque Rust types exposed to Tish (e.g. Polars DataFrame).
 /// Implementors provide method dispatch so Tish can call methods on the value.
@@ -54,29 +63,70 @@ impl RegExpFlags {
         let mut result = Self::default();
         for c in flags.chars() {
             match c {
-                'g' => { if result.global { return Err(format!("duplicate flag '{}'", c)); } result.global = true; }
-                'i' => { if result.ignore_case { return Err(format!("duplicate flag '{}'", c)); } result.ignore_case = true; }
-                'm' => { if result.multiline { return Err(format!("duplicate flag '{}'", c)); } result.multiline = true; }
-                's' => { if result.dot_all { return Err(format!("duplicate flag '{}'", c)); } result.dot_all = true; }
-                'u' => { if result.unicode { return Err(format!("duplicate flag '{}'", c)); } result.unicode = true; }
-                'y' => { if result.sticky { return Err(format!("duplicate flag '{}'", c)); } result.sticky = true; }
+                'g' => {
+                    if result.global {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.global = true;
+                }
+                'i' => {
+                    if result.ignore_case {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.ignore_case = true;
+                }
+                'm' => {
+                    if result.multiline {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.multiline = true;
+                }
+                's' => {
+                    if result.dot_all {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.dot_all = true;
+                }
+                'u' => {
+                    if result.unicode {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.unicode = true;
+                }
+                'y' => {
+                    if result.sticky {
+                        return Err(format!("duplicate flag '{}'", c));
+                    }
+                    result.sticky = true;
+                }
                 _ => return Err(format!("unknown flag '{}'", c)),
             }
         }
         Ok(result)
     }
-
 }
 
 #[cfg(feature = "regex")]
 impl std::fmt::Display for RegExpFlags {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.global { f.write_str("g")?; }
-        if self.ignore_case { f.write_str("i")?; }
-        if self.multiline { f.write_str("m")?; }
-        if self.dot_all { f.write_str("s")?; }
-        if self.unicode { f.write_str("u")?; }
-        if self.sticky { f.write_str("y")?; }
+        if self.global {
+            f.write_str("g")?;
+        }
+        if self.ignore_case {
+            f.write_str("i")?;
+        }
+        if self.multiline {
+            f.write_str("m")?;
+        }
+        if self.dot_all {
+            f.write_str("s")?;
+        }
+        if self.unicode {
+            f.write_str("u")?;
+        }
+        if self.sticky {
+            f.write_str("y")?;
+        }
         Ok(())
     }
 }
@@ -96,23 +146,36 @@ impl TishRegExp {
     pub fn new(pattern: &str, flags_str: &str) -> Result<Self, String> {
         let flags = RegExpFlags::from_string(flags_str)?;
         let mut regex_pattern = pattern.to_string();
-        
+
         if flags.ignore_case || flags.multiline || flags.dot_all {
             let mut flag_prefix = String::from("(?");
-            if flags.ignore_case { flag_prefix.push('i'); }
-            if flags.multiline { flag_prefix.push('m'); }
-            if flags.dot_all { flag_prefix.push('s'); }
+            if flags.ignore_case {
+                flag_prefix.push('i');
+            }
+            if flags.multiline {
+                flag_prefix.push('m');
+            }
+            if flags.dot_all {
+                flag_prefix.push('s');
+            }
             flag_prefix.push(')');
             regex_pattern = format!("{}{}", flag_prefix, regex_pattern);
         }
-        
-        let regex = Regex::new(&regex_pattern)
-            .map_err(|e| format!("Invalid regular expression: {}", e))?;
-        
-        Ok(Self { source: pattern.to_string(), flags, regex: Arc::new(regex), last_index: 0 })
+
+        let regex =
+            Regex::new(&regex_pattern).map_err(|e| format!("Invalid regular expression: {}", e))?;
+
+        Ok(Self {
+            source: pattern.to_string(),
+            flags,
+            regex: Arc::new(regex),
+            last_index: 0,
+        })
     }
 
-    pub fn flags_string(&self) -> String { self.flags.to_string() }
+    pub fn flags_string(&self) -> String {
+        self.flags.to_string()
+    }
 
     pub fn test(&mut self, input: &str) -> bool {
         if self.flags.global || self.flags.sticky {
@@ -121,10 +184,10 @@ impl TishRegExp {
                 self.last_index = 0;
                 return false;
             }
-            
+
             let byte_start: usize = input.chars().take(start).map(|c| c.len_utf8()).sum();
             let search_str = &input[byte_start..];
-            
+
             match self.regex.find(search_str) {
                 Ok(Some(m)) => {
                     if self.flags.sticky && m.start() != 0 {
@@ -148,17 +211,21 @@ impl TishRegExp {
 
 /// Runtime value for Tish programs.
 /// Used by both interpreter and compiled code.
+///
+/// **Thread safety**: `Value: Send + Sync`. Mutable payloads live inside
+/// [`VmRef`], a `Send + Sync` `Arc<Mutex<T>>` wrapper that preserves the
+/// `RefCell`-style borrow API. Functions are `Arc<dyn Fn + Send + Sync>`.
 #[derive(Clone)]
 pub enum Value {
     Number(f64),
     String(Arc<str>),
     Bool(bool),
     Null,
-    Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<ObjectMap>>),
+    Array(VmRef<Vec<Value>>),
+    Object(VmRef<ObjectMap>),
     Function(NativeFn),
     #[cfg(feature = "regex")]
-    RegExp(Rc<RefCell<TishRegExp>>),
+    RegExp(VmRef<TishRegExp>),
     /// Promise (for native compile). Interpreter uses tishlang_eval::Value::Promise.
     Promise(Arc<dyn TishPromise>),
     /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
@@ -176,7 +243,12 @@ impl std::fmt::Debug for Value {
             Value::Object(obj) => write!(f, "Object({:?})", obj.borrow()),
             Value::Function(_) => write!(f, "Function"),
             #[cfg(feature = "regex")]
-            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            Value::RegExp(re) => write!(
+                f,
+                "RegExp(/{}/{})",
+                re.borrow().source,
+                re.borrow().flags_string()
+            ),
             Value::Promise(_) => write!(f, "Promise"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
         }
@@ -202,7 +274,8 @@ impl Value {
             Value::Bool(b) => b.to_string(),
             Value::Null => "null".to_string(),
             Value::Array(arr) => {
-                let inner: Vec<String> = arr.borrow().iter().map(|v| v.to_display_string()).collect();
+                let inner: Vec<String> =
+                    arr.borrow().iter().map(|v| v.to_display_string()).collect();
                 format!("[{}]", inner.join(", "))
             }
             Value::Object(obj) => {
@@ -248,35 +321,60 @@ impl Value {
             (Value::String(a), Value::String(b)) => a == b,
             (Value::Bool(a), Value::Bool(b)) => a == b,
             (Value::Null, Value::Null) => true,
-            (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
-            (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
-            (Value::Function(a), Value::Function(b)) => Rc::ptr_eq(a, b),
+            (Value::Array(a), Value::Array(b)) => VmRef::ptr_eq(a, b),
+            (Value::Object(a), Value::Object(b)) => VmRef::ptr_eq(a, b),
+            #[cfg(feature = "send-values")]
+            (Value::Function(a), Value::Function(b)) => Arc::ptr_eq(a, b),
+            #[cfg(not(feature = "send-values"))]
+            (Value::Function(a), Value::Function(b)) => std::rc::Rc::ptr_eq(a, b),
             #[cfg(feature = "regex")]
-            (Value::RegExp(a), Value::RegExp(b)) => Rc::ptr_eq(a, b),
+            (Value::RegExp(a), Value::RegExp(b)) => VmRef::ptr_eq(a, b),
             (Value::Promise(a), Value::Promise(b)) => Arc::ptr_eq(a, b),
             (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
             _ => false,
         }
     }
 
+    /// Wrap a Rust closure in a `Value::Function`. Automatically picks
+    /// `Rc<dyn Fn>` or `Arc<dyn Fn + Send + Sync>` based on the
+    /// `send-values` feature, so callers don't have to `cfg`-gate their
+    /// code. The input bound tracks the feature too: when `send-values`
+    /// is enabled the closure must be `Send + Sync`, otherwise any `Fn`
+    /// is accepted.
+    #[cfg(feature = "send-values")]
+    pub fn native<F>(f: F) -> Self
+    where
+        F: Fn(&[Value]) -> Value + Send + Sync + 'static,
+    {
+        Value::Function(Arc::new(f))
+    }
+
+    #[cfg(not(feature = "send-values"))]
+    pub fn native<F>(f: F) -> Self
+    where
+        F: Fn(&[Value]) -> Value + 'static,
+    {
+        Value::Function(std::rc::Rc::new(f))
+    }
+
     /// Create a new array Value from a Vec.
     pub fn array(items: Vec<Value>) -> Self {
-        Value::Array(Rc::new(RefCell::new(items)))
+        Value::Array(VmRef::new(items))
     }
 
     /// Create a new object Value from a property map.
     pub fn object(map: ObjectMap) -> Self {
-        Value::Object(Rc::new(RefCell::new(map)))
+        Value::Object(VmRef::new(map))
     }
 
     /// Create an empty array Value.
     pub fn empty_array() -> Self {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 
     /// Create an empty object Value.
     pub fn empty_object() -> Self {
-        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
+        Value::Object(VmRef::new(ObjectMap::default()))
     }
 
     /// Extract the number value, if this is a Number.
@@ -378,7 +476,11 @@ impl Value {
                     "trim".into(),
                 ]
             }
-            Value::Number(_) => vec!["toFixed".into(), "toExponential".into(), "toPrecision".into()],
+            Value::Number(_) => vec![
+                "toFixed".into(),
+                "toExponential".into(),
+                "toPrecision".into(),
+            ],
             _ => vec![],
         }
     }

package/crates/tish_core/src/vmref.rs

@@ -0,0 +1,178 @@
+//! Shared-mutable reference used by the Tish runtime for `Value::Array`,
+//! `Value::Object`, and `Value::RegExp` payloads.
+//!
+//! ## Why this exists
+//!
+//! Tish's `Value` uses interior mutability for arrays, objects, and regex
+//! state. Historically that was `Rc<RefCell<T>>`, which is fast but
+//! `!Send` — so `Value` couldn't move across threads, which in turn meant
+//! `serve(port, handler)` had to serialise every request through one
+//! VM dispatcher thread.
+//!
+//! `VmRef<T>` lets the build system pick the right trade-off **per
+//! compile target**:
+//!
+//! | feature `send-values`     | `VmRef<T>`              | `NativeFn`                       | targets                                          |
+//! |---------------------------|-------------------------|----------------------------------|--------------------------------------------------|
+//! | **off** *(default)*       | `Rc<RefCell<T>>`        | `Rc<dyn Fn + 'static>`           | wasm32, wasi, interpreter, cranelift/llvm VMs    |
+//! | **on**                    | `Arc<Mutex<T>>`         | `Arc<dyn Fn + Send + Sync>`      | Rust native with `http` enabled (server workloads) |
+//!
+//! The *API* is identical in both configurations (`borrow` / `borrow_mut`
+//! / `ptr_eq` / `Clone`), so every existing call site in the workspace
+//! compiles unchanged. What flips is only the underlying primitive.
+//!
+//! ## Why this matters for performance
+//!
+//! * **wasm / wasi / cranelift / llvm / interpreter**: still pure
+//!   `Rc<RefCell<T>>`. Zero atomic ops, no mutex churn, behaviour
+//!   bit-identical to the pre-migration baseline.
+//! * **Rust native, non-server**: same — `send-values` only activates
+//!   when something in the dependency graph (usually `http`) needs it.
+//! * **Rust native with server**: `Arc<Mutex<T>>` pays ~3–5 ns per
+//!   `borrow` in the uncontended case (single atomic CAS). On Tish's
+//!   hot paths — roughly 6–12 borrows per request — that's ~30–60 ns of
+//!   overhead. In exchange we get `N×` handler scaling across cores,
+//!   which recovers orders of magnitude more throughput than it costs.
+//!
+//! ## API surface
+//!
+//! ```ignore
+//! let cell = VmRef::new(42);
+//! *cell.borrow() + 1;          // read
+//! *cell.borrow_mut() = 99;     // write
+//! VmRef::ptr_eq(&a, &b);       // identity
+//! let clone = cell.clone();    // shared ownership
+//! ```
+//!
+//! Returned guard types (`VmReadGuard<'_, T>`, `VmWriteGuard<'_, T>`) are
+//! type aliases that pick `Ref`/`RefMut` or `MutexGuard` depending on the
+//! feature. They both `Deref` (and, for write guards, `DerefMut`) to `T`
+//! just like the underlying types.
+
+use std::fmt;
+
+// --------------------------------------------------------------------------
+// Single-threaded backing store (default): Rc<RefCell<T>>
+// --------------------------------------------------------------------------
+#[cfg(not(feature = "send-values"))]
+mod imp {
+    use std::cell::RefCell;
+    use std::rc::Rc;
+
+    #[derive(Default)]
+    pub struct VmRef<T: ?Sized>(pub(super) Rc<RefCell<T>>);
+
+    /// Read guard alias. On the single-threaded path this is a true
+    /// `Ref<'_, T>`, so multiple readers can coexist.
+    pub type ReadGuard<'a, T> = std::cell::Ref<'a, T>;
+    /// Write guard alias. Exclusive, `DerefMut`.
+    pub type WriteGuard<'a, T> = std::cell::RefMut<'a, T>;
+
+    impl<T> VmRef<T> {
+        #[inline]
+        pub fn new(value: T) -> Self {
+            VmRef(Rc::new(RefCell::new(value)))
+        }
+    }
+
+    impl<T: ?Sized> VmRef<T> {
+        #[inline]
+        pub fn borrow(&self) -> ReadGuard<'_, T> {
+            self.0.borrow()
+        }
+
+        #[inline]
+        pub fn borrow_mut(&self) -> WriteGuard<'_, T> {
+            self.0.borrow_mut()
+        }
+
+        #[inline]
+        pub fn ptr_eq(a: &Self, b: &Self) -> bool {
+            Rc::ptr_eq(&a.0, &b.0)
+        }
+
+        #[inline]
+        pub fn strong_count(this: &Self) -> usize {
+            Rc::strong_count(&this.0)
+        }
+    }
+
+    impl<T: ?Sized> Clone for VmRef<T> {
+        #[inline]
+        fn clone(&self) -> Self {
+            VmRef(Rc::clone(&self.0))
+        }
+    }
+}
+
+// --------------------------------------------------------------------------
+// Thread-safe backing store (opt-in): Arc<Mutex<T>>
+// --------------------------------------------------------------------------
+#[cfg(feature = "send-values")]
+mod imp {
+    use std::sync::{Arc, Mutex};
+
+    #[derive(Default)]
+    pub struct VmRef<T: ?Sized>(pub(super) Arc<Mutex<T>>);
+
+    /// Read guard alias. On the multi-threaded path both readers and
+    /// writers share a single `MutexGuard` (exclusive access).
+    pub type ReadGuard<'a, T> = std::sync::MutexGuard<'a, T>;
+    /// Write guard alias.
+    pub type WriteGuard<'a, T> = std::sync::MutexGuard<'a, T>;
+
+    impl<T> VmRef<T> {
+        #[inline]
+        pub fn new(value: T) -> Self {
+            VmRef(Arc::new(Mutex::new(value)))
+        }
+    }
+
+    impl<T: ?Sized> VmRef<T> {
+        /// Acquire the inner mutex. Poisoning is swallowed — a Tish
+        /// handler panic already aborts the enclosing thread; there is
+        /// no invariant worth preserving past that point.
+        #[inline]
+        pub fn borrow(&self) -> ReadGuard<'_, T> {
+            self.0.lock().unwrap_or_else(|p| p.into_inner())
+        }
+
+        #[inline]
+        pub fn borrow_mut(&self) -> WriteGuard<'_, T> {
+            self.0.lock().unwrap_or_else(|p| p.into_inner())
+        }
+
+        #[inline]
+        pub fn ptr_eq(a: &Self, b: &Self) -> bool {
+            Arc::ptr_eq(&a.0, &b.0)
+        }
+
+        #[inline]
+        pub fn strong_count(this: &Self) -> usize {
+            Arc::strong_count(&this.0)
+        }
+    }
+
+    impl<T: ?Sized> Clone for VmRef<T> {
+        #[inline]
+        fn clone(&self) -> Self {
+            VmRef(Arc::clone(&self.0))
+        }
+    }
+}
+
+pub use imp::{ReadGuard as VmReadGuard, VmRef, WriteGuard as VmWriteGuard};
+
+impl<T: fmt::Debug> fmt::Debug for VmRef<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Match `RefCell`'s debug format so snapshot-test output stays
+        // stable across the migration.
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            let guard = self.borrow();
+            format!("{:?}", &*guard)
+        })) {
+            Ok(s) => write!(f, "RefCell {{ value: {} }}", s),
+            Err(_) => write!(f, "RefCell {{ value: <borrowed> }}"),
+        }
+    }
+}

package/crates/tish_cranelift/src/link.rs

@@ -12,9 +12,8 @@ pub fn link_to_binary(
     output_path: &Path,
     features: &[String],
 ) -> Result<(), CraneliftError> {
-    let workspace_root = tishlang_build_utils::find_workspace_root().map_err(|e| CraneliftError {
-        message: e,
-    })?;
+    let workspace_root =
+        tishlang_build_utils::find_workspace_root().map_err(|e| CraneliftError { message: e })?;
     let out_name = output_path
         .file_stem()
         .and_then(|s| s.to_str())
@@ -104,17 +103,15 @@ fn main() {{
         message: format!("Cannot write build.rs: {}", e),
     })?;
 
-    tishlang_build_utils::run_cargo_build(&build_dir, None).map_err(|e| CraneliftError { message: e })?;
+    tishlang_build_utils::run_cargo_build(&build_dir, None)
+        .map_err(|e| CraneliftError { message: e })?;
 
     let binary_dir = build_dir.join("target").join("release");
-    let binary =
-        tishlang_build_utils::find_release_binary(&binary_dir, out_name)
-            .map_err(|e| CraneliftError { message: e })?;
+    let binary = tishlang_build_utils::find_release_binary(&binary_dir, out_name)
+        .map_err(|e| CraneliftError { message: e })?;
     let target = tishlang_build_utils::resolve_output_path(output_path, out_name);
     tishlang_build_utils::copy_binary_to_output(&binary, &target)
         .map_err(|e| CraneliftError { message: e })?;
 
     Ok(())
 }
-
-

package/crates/tish_cranelift/src/lower.rs

@@ -7,8 +7,8 @@
 
 use std::path::Path;
 
-use cranelift::codegen::settings::Configurable;
 use cranelift::codegen::settings;
+use cranelift::codegen::settings::Configurable;
 use cranelift_module::{DataDescription, Linkage, Module};
 use cranelift_object::{ObjectBuilder, ObjectModule};
 
@@ -18,9 +18,11 @@ use crate::CraneliftError;
 
 pub fn lower_and_emit(chunk: &Chunk, object_path: &Path) -> Result<(), CraneliftError> {
     let mut settings_builder = settings::builder();
-    settings_builder.set("opt_level", "speed").map_err(|_| CraneliftError {
-        message: "Failed to set opt_level".to_string(),
-    })?;
+    settings_builder
+        .set("opt_level", "speed")
+        .map_err(|_| CraneliftError {
+            message: "Failed to set opt_level".to_string(),
+        })?;
     let flags = settings::Flags::new(settings_builder);
 
     let isa_builder = cranelift_native::builder().map_err(|e| CraneliftError {
@@ -30,10 +32,14 @@ pub fn lower_and_emit(chunk: &Chunk, object_path: &Path) -> Result<(), Cranelift
         message: format!("Failed to finish ISA: {}", e),
     })?;
 
-    let object_builder = ObjectBuilder::new(isa, "tishlang_cranelift", cranelift_module::default_libcall_names())
-        .map_err(|e| CraneliftError {
-            message: format!("Failed to create ObjectBuilder: {}", e),
-        })?;
+    let object_builder = ObjectBuilder::new(
+        isa,
+        "tishlang_cranelift",
+        cranelift_module::default_libcall_names(),
+    )
+    .map_err(|e| CraneliftError {
+        message: format!("Failed to create ObjectBuilder: {}", e),
+    })?;
     let mut module = ObjectModule::new(object_builder);
 
     // Serialize chunk and emit as data - link step will build a Rust binary that reads it

package/crates/tish_eval/Cargo.toml

@@ -8,7 +8,22 @@ license-file = { workspace = true }
 repository = { workspace = true }
 [features]
 default = []
-http = ["tokio", "reqwest", "futures", "tiny_http", "tishlang_core/regex", "dep:tishlang_runtime", "tishlang_runtime/http"]
+# setTimeout / setInterval / clear* (standalone or with `import { … } from "tish:timers"`).
+timers = []
+http = [
+    "timers",
+    "tokio",
+    "reqwest",
+    "futures",
+    "tiny_http",
+    "tishlang_core/regex",
+    "dep:tishlang_runtime",
+    "tishlang_runtime/http",
+    # Interpreter + http means the runtime's `NativeFn` is `Arc<... + Send>`,
+    # so the interpreter's `CoreFn` variant must use the same shape.
+    "tishlang_core/send-values",
+    "tishlang_builtins/send-values",
+]
 fs = []
 process = []
 regex = ["dep:fancy-regex", "tishlang_core/regex"]
@@ -17,7 +32,7 @@ ws = ["dep:tishlang_runtime", "tishlang_runtime/ws"]
 
 [dependencies]
 ahash = "0.8.12"
-rand = "0.10.0"
+rand = "0.10.1"
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }