@tishlang/tish 1.7.0 → 1.9.0

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -17,6 +17,7 @@ pub struct VirtualModule {
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
     ("http", "tish:http"),
+    ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
 ];
@@ -35,7 +36,7 @@ fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with('@')
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Normalize a virtual path: resolve . and .. components.
@@ -311,8 +312,14 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                             normalize_builtin_spec(from).unwrap_or_else(|| from.to_string());
                         for spec in specifiers {
                             match spec {
-                                ImportSpecifier::Named { name, alias } => {
+                                ImportSpecifier::Named {
+                                    name,
+                                    name_span,
+                                    alias,
+                                    alias_span,
+                                } => {
                                     let bind = alias.as_deref().unwrap_or(name.as_ref());
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     let init = Expr::NativeModuleLoad {
                                         spec: Arc::from(canonical_spec.clone()),
                                         export_name: name.clone(),
@@ -320,23 +327,24 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     };
                                     statements.push(Statement::VarDecl {
                                         name: Arc::from(bind),
+                                        name_span: *decl_name_span,
                                         mutable: false,
                                         type_ann: None,
                                         init: Some(init),
                                         span: *span,
                                     });
                                 }
-                                ImportSpecifier::Namespace(ns) => {
+                                ImportSpecifier::Namespace { name, .. } => {
                                     return Err(format!(
                                         "Namespace import (* as {}) not supported for native module '{}'",
-                                        ns.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
-                                ImportSpecifier::Default(bind) => {
+                                ImportSpecifier::Default { name, .. } => {
                                     return Err(format!(
                                         "Default import '{}' not supported for native module '{}'. Use named import.",
-                                        bind.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
@@ -351,15 +359,22 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                     let dep_exports = &module_exports[dep_idx];
                     for spec in specifiers {
                         match spec {
-                            ImportSpecifier::Named { name, alias } => {
+                            ImportSpecifier::Named {
+                                name,
+                                name_span,
+                                alias,
+                                alias_span,
+                            } => {
                                 let source = dep_exports
                                     .get(name.as_ref())
                                     .cloned()
                                     .unwrap_or_else(|| name.to_string());
                                 let bind = alias.as_deref().unwrap_or(name.as_ref());
                                 if bind != source {
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     statements.push(Statement::VarDecl {
                                         name: Arc::from(bind),
+                                        name_span: *decl_name_span,
                                         mutable: false,
                                         type_ann: None,
                                         init: Some(Expr::Ident {
@@ -370,7 +385,7 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     });
                                 }
                             }
-                            ImportSpecifier::Namespace(ns) => {
+                            ImportSpecifier::Namespace { name, name_span } => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
                                     props.push(tishlang_ast::ObjectProp::KeyValue(
@@ -382,20 +397,22 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                                     ));
                                 }
                                 statements.push(Statement::VarDecl {
-                                    name: ns.clone(),
+                                    name: name.clone(),
+                                    name_span: *name_span,
                                     mutable: false,
                                     type_ann: None,
                                     init: Some(Expr::Object { props, span: *span }),
                                     span: *span,
                                 });
                             }
-                            ImportSpecifier::Default(bind) => {
+                            ImportSpecifier::Default { name, name_span } => {
                                 let source =
                                     dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
                                 statements.push(Statement::VarDecl {
-                                    name: bind.clone(),
+                                    name: name.clone(),
+                                    name_span: *name_span,
                                     mutable: false,
                                     type_ann: None,
                                     init: Some(Expr::Ident {
@@ -412,12 +429,14 @@ pub fn merge_modules_virtual(modules: Vec<VirtualModule>) -> Result<Program, Str
                     ExportDeclaration::Named(s) => statements.push(*s.clone()),
                     ExportDeclaration::Default(e) => {
                         let default_name = format!("__default_{}", idx);
+                        let espan = e.span();
                         statements.push(Statement::VarDecl {
                             name: Arc::from(default_name),
+                            name_span: espan,
                             mutable: false,
                             type_ann: None,
                             init: Some((*e).clone()),
-                            span: e.span(),
+                            span: espan,
                         });
                     }
                 },

package/crates/tish_core/Cargo.toml

@@ -9,6 +9,14 @@ repository = { workspace = true }
 [features]
 default = []
 regex = ["dep:fancy-regex"]
+# Make `Value` (and its array / object / regex payloads) `Send + Sync` by
+# switching the interior `Rc<RefCell<T>>` to `Arc<Mutex<T>>` and the native
+# function type from `Rc<dyn Fn>` to `Arc<dyn Fn + Send + Sync>`. Enabled
+# transitively by any crate that needs to pass `Value`s across threads —
+# most notably `tishlang_runtime/http`, which dispatches HTTP handlers
+# across a worker pool. Off by default so wasm / wasi / cranelift / llvm /
+# interpreter builds pay no atomic-ref-count or mutex overhead.
+send-values = []
 
 [dependencies]
 ahash = "0.8.11"

package/crates/tish_core/src/json.rs

@@ -1,8 +1,6 @@
 //! JSON parsing and stringification for Tish values.
 
-use crate::Value;
-use std::cell::RefCell;
-use std::rc::Rc;
+use crate::{Value, VmRef};
 use std::sync::Arc;
 
 /// Parse JSON string into a Value.
@@ -19,75 +17,126 @@ pub fn json_parse(json: &str) -> Result<Value, String> {
 }
 
 /// Stringify a Value to JSON.
+///
+/// Single-buffer write strategy: all nested values append into one
+/// `String` via [`json_stringify_into`], so we never allocate a transient
+/// per-node `String` only to copy + drop it on the way back up. For a
+/// 20-row TFB `/queries` response (~40 numbers, 2 keys × 20 = ~80 string
+/// ops) that saves dozens of small allocations per request.
 pub fn json_stringify(value: &Value) -> String {
+    // 256 B is enough for typical TFB responses (`/db` is 31 B,
+    // `/queries=20` is ~700 B). Larger payloads reallocate normally.
+    let mut buf = String::with_capacity(256);
+    json_stringify_into(&mut buf, value);
+    buf
+}
+
+/// Append a JSON-stringified `value` to `buf`. Used by JSON.stringify for
+/// the recursive case so we don't pay for an intermediate `String` per
+/// node.
+pub fn json_stringify_into(buf: &mut String, value: &Value) {
     match value {
-        Value::Null => "null".to_string(),
-        Value::Bool(b) => b.to_string(),
+        Value::Null => buf.push_str("null"),
+        Value::Bool(true) => buf.push_str("true"),
+        Value::Bool(false) => buf.push_str("false"),
         Value::Number(n) => {
             if n.is_nan() || n.is_infinite() {
-                "null".to_string()
+                buf.push_str("null");
             } else {
-                n.to_string()
+                // `write!` avoids the heap allocation that `to_string`
+                // produces. The f64 → decimal formatter is the same
+                // either way (`std::fmt::Display`).
+                use std::fmt::Write;
+                let _ = write!(buf, "{}", n);
             }
         }
-        Value::String(s) => format!("\"{}\"", escape_json_string(s)),
+        Value::String(s) => {
+            buf.push('"');
+            escape_json_string_into(buf, s);
+            buf.push('"');
+        }
         Value::Array(arr) => {
             let borrowed = arr.borrow();
-            let mut result = String::with_capacity(borrowed.len() * 8 + 2);
-            result.push('[');
-            let mut first = true;
-            for item in borrowed.iter() {
-                if !first {
-                    result.push(',');
+            buf.push('[');
+            for (i, item) in borrowed.iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
                 }
-                first = false;
-                result.push_str(&json_stringify(item));
+                json_stringify_into(buf, item);
             }
-            result.push(']');
-            result
+            buf.push(']');
         }
         Value::Object(obj) => {
             let borrowed = obj.borrow();
-            let mut keys: Vec<_> = borrowed.keys().collect();
-            keys.sort();
-            let mut result = String::with_capacity(borrowed.len() * 16 + 2);
-            result.push('{');
-            let mut first = true;
-            for key in keys {
-                if !first {
-                    result.push(',');
+            // Sort keys for deterministic output. Pre-allocate to avoid
+            // a fresh `Vec` realloc inside `keys().collect()`.
+            let mut keys: Vec<&Arc<str>> = Vec::with_capacity(borrowed.len());
+            keys.extend(borrowed.keys());
+            keys.sort_unstable_by(|a, b| a.as_ref().cmp(b.as_ref()));
+            buf.push('{');
+            for (i, key) in keys.into_iter().enumerate() {
+                if i > 0 {
+                    buf.push(',');
                 }
-                first = false;
-                result.push('"');
-                result.push_str(&escape_json_string(key));
-                result.push_str("\":");
-                result.push_str(&json_stringify(borrowed.get(key).unwrap()));
+                buf.push('"');
+                escape_json_string_into(buf, key);
+                buf.push_str("\":");
+                json_stringify_into(buf, borrowed.get(key).unwrap());
             }
-            result.push('}');
-            result
+            buf.push('}');
         }
-        Value::Function(_) => "null".to_string(),
-        Value::Promise(_) => "null".to_string(),
-        Value::Opaque(_) => "null".to_string(),
+        Value::Function(_) | Value::Promise(_) | Value::Opaque(_) => buf.push_str("null"),
         #[cfg(feature = "regex")]
-        Value::RegExp(_) => "null".to_string(),
+        Value::RegExp(_) => buf.push_str("null"),
     }
 }
 
-fn escape_json_string(s: &str) -> String {
-    let mut result = String::with_capacity(s.len());
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            '\\' => result.push_str("\\\\"),
-            '\n' => result.push_str("\\n"),
-            '\r' => result.push_str("\\r"),
-            '\t' => result.push_str("\\t"),
-            c if c.is_control() => result.push_str(&format!("\\u{:04x}", c as u32)),
-            c => result.push(c),
+/// Append an escaped JSON string body (without the surrounding quotes)
+/// to `buf`. Optimised for the common case where the input is ASCII and
+/// contains no characters that need escaping — we fast-pass the bytes
+/// straight through, only falling into the per-char path on a hit.
+fn escape_json_string_into(buf: &mut String, s: &str) {
+    let bytes = s.as_bytes();
+    let mut start = 0usize;
+    for (i, &b) in bytes.iter().enumerate() {
+        // Anything < 0x20 is a JSON control char that must be escaped;
+        // 0x22 (`"`) and 0x5C (`\`) also need an explicit escape; bytes
+        // ≥ 0x80 are the start of a multi-byte UTF-8 sequence, which is
+        // valid JSON as-is.
+        if b < 0x20 || b == b'"' || b == b'\\' {
+            // Flush the run of clean bytes before this one in one push.
+            if start < i {
+                // SAFETY: `s` is `&str`, every byte in `start..i` was a
+                // single-byte ASCII char (we only stop on ASCII triggers
+                // below 0x80), so the slice is a valid `&str`.
+                buf.push_str(&s[start..i]);
+            }
+            match b {
+                b'"' => buf.push_str("\\\""),
+                b'\\' => buf.push_str("\\\\"),
+                b'\n' => buf.push_str("\\n"),
+                b'\r' => buf.push_str("\\r"),
+                b'\t' => buf.push_str("\\t"),
+                b'\x08' => buf.push_str("\\b"),
+                b'\x0c' => buf.push_str("\\f"),
+                _ => {
+                    use std::fmt::Write;
+                    let _ = write!(buf, "\\u{:04x}", b as u32);
+                }
+            }
+            start = i + 1;
         }
     }
-    result
+    if start < bytes.len() {
+        buf.push_str(&s[start..]);
+    }
+}
+
+#[allow(dead_code)]
+fn escape_json_string(s: &str) -> String {
+    let mut buf = String::with_capacity(s.len());
+    escape_json_string_into(&mut buf, s);
+    buf
 }
 
 fn parse_value(input: &str) -> Result<(Value, &str), String> {
@@ -241,7 +290,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix(']') {
-        return Ok((Value::Array(Rc::new(RefCell::new(items))), rest));
+        return Ok((Value::Array(VmRef::new(items)), rest));
     }
 
     loop {
@@ -251,7 +300,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some(']') => return Ok((Value::Array(Rc::new(RefCell::new(items))), &input[1..])),
+            Some(']') => return Ok((Value::Array(VmRef::new(items)), &input[1..])),
             _ => return Err("Expected ',' or ']' in array".to_string()),
         }
     }
@@ -263,7 +312,7 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {
-        return Ok((Value::Object(Rc::new(RefCell::new(map))), rest));
+        return Ok((Value::Object(VmRef::new(map)), rest));
     }
 
     loop {
@@ -290,7 +339,7 @@ fn parse_object(input: &str) -> Result<(Value, &str), String> {
 
         match input.chars().next() {
             Some(',') => input = &input[1..],
-            Some('}') => return Ok((Value::Object(Rc::new(RefCell::new(map))), &input[1..])),
+            Some('}') => return Ok((Value::Object(VmRef::new(map)), &input[1..])),
             _ => return Err("Expected ',' or '}' in object".to_string()),
         }
     }

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 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/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.
@@ -202,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).
@@ -308,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.