@tishlang/tish 1.7.0 → 1.9.0

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_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" }

package/crates/tish_eval/src/eval.rs

@@ -109,6 +109,7 @@ impl Evaluator {
             );
             s.set("decodeURI".into(), Value::Native(natives::decode_uri), true);
             s.set("encodeURI".into(), Value::Native(natives::encode_uri), true);
+            s.set("htmlEscape".into(), Value::Native(natives::html_escape), true);
             s.set(
                 "Boolean".into(),
                 Value::Native(natives::boolean_native),
@@ -221,7 +222,37 @@ impl Evaluator {
                 );
             }
 
-            // fs, http, process: use import { x } from 'tish:fs' etc. No globals.
+            // fs, process: prefer `import { x } from 'tish:fs'` etc.
+            #[cfg(feature = "timers")]
+            {
+                s.set(
+                    "setTimeout".into(),
+                    Value::TimerBuiltin(Arc::from("setTimeout")),
+                    true,
+                );
+                s.set(
+                    "setInterval".into(),
+                    Value::TimerBuiltin(Arc::from("setInterval")),
+                    true,
+                );
+                s.set(
+                    "clearTimeout".into(),
+                    Value::Native(Self::clear_timeout_native),
+                    true,
+                );
+                s.set(
+                    "clearInterval".into(),
+                    Value::Native(Self::clear_interval_native),
+                    true,
+                );
+            }
+            #[cfg(feature = "http")]
+            {
+                s.set("fetch".into(), Value::Native(Self::fetch_native), true);
+                s.set("fetchAll".into(), Value::Native(Self::fetch_all_native), true);
+                s.set("Promise".into(), Value::PromiseConstructor, true);
+                s.set("serve".into(), Value::Serve, true);
+            }
         }
         Self {
             scope,
@@ -556,21 +587,21 @@ impl Evaluator {
                 let mut scope = self.scope.borrow_mut();
                 for spec in specifiers {
                     match spec {
-                        ImportSpecifier::Named { name, alias } => {
+                        ImportSpecifier::Named { name, alias, .. } => {
                             let v = exports.get(name.as_ref()).ok_or_else(|| {
                                 EvalError::Error(format!("Module does not export '{}'", name))
                             })?;
                             let bind = alias.as_deref().unwrap_or(name.as_ref());
                             scope.set(Arc::from(bind), v.clone(), false);
                         }
-                        ImportSpecifier::Namespace(ns) => {
-                            scope.set(Arc::clone(ns), exports_val.clone(), false);
+                        ImportSpecifier::Namespace { name, .. } => {
+                            scope.set(Arc::clone(name), exports_val.clone(), false);
                         }
-                        ImportSpecifier::Default(bind) => {
+                        ImportSpecifier::Default { name, .. } => {
                             let v = exports.get("default").ok_or_else(|| {
                                 EvalError::Error("Module does not have default export".to_string())
                             })?;
-                            scope.set(Arc::clone(bind), v.clone(), false);
+                            scope.set(Arc::clone(name), v.clone(), false);
                         }
                     }
                 }
@@ -588,6 +619,9 @@ impl Evaluator {
                 }
                 Ok(Value::Null)
             }
+            Statement::TypeAlias { .. } | Statement::DeclareVar { .. } | Statement::DeclareFun { .. } => {
+                Ok(Value::Null)
+            }
         }
     }
 
@@ -726,6 +760,19 @@ impl Evaluator {
                     exports.insert("fetchAll".into(), Value::Native(Self::fetch_all_native));
                     exports.insert("serve".into(), Value::Serve);
                     exports.insert("Promise".into(), Value::PromiseConstructor);
+                    return Ok(Value::Object(Rc::new(RefCell::new(exports))));
+                }
+                #[cfg(not(feature = "http"))]
+                {
+                    return Err(EvalError::Error(
+                        "tish:http requires the http feature. Rebuild with: cargo build -p tishlang --features http".into(),
+                    ));
+                }
+            }
+            "tish:timers" => {
+                #[cfg(feature = "timers")]
+                {
+                    let mut exports: PropMap = PropMap::default();
                     exports.insert(
                         "setTimeout".into(),
                         Value::TimerBuiltin(Arc::from("setTimeout")),
@@ -744,10 +791,10 @@ impl Evaluator {
                     );
                     return Ok(Value::Object(Rc::new(RefCell::new(exports))));
                 }
-                #[cfg(not(feature = "http"))]
+                #[cfg(not(feature = "timers"))]
                 {
                     return Err(EvalError::Error(
-                        "tish:http requires the http feature. Rebuild with: cargo build -p tishlang --features http".into(),
+                        "tish:timers requires the timers feature. Rebuild with: cargo build -p tishlang --features timers".into(),
                     ));
                 }
             }
@@ -815,7 +862,7 @@ impl Evaluator {
             }
             _ => {
                 return Err(EvalError::Error(format!(
-                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:process, tish:ws (plus any registered by native modules)",
+                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:timers, tish:process, tish:ws (plus any registered by native modules)",
                     spec
                 )));
             }
@@ -862,7 +909,12 @@ impl Evaluator {
             }
             Expr::Call { callee, args, .. } => {
                 // Check for built-in method calls on arrays/strings
-                if let Expr::Member { object, prop: MemberProp::Name(method_name), .. } = callee.as_ref() {
+                if let Expr::Member {
+                    object,
+                    prop: MemberProp::Name { name: method_name, .. },
+                    ..
+                } = callee.as_ref()
+                {
                     let obj = self.eval_expr(object)?;
                     let arg_vals = self.eval_call_args(args)?;
                     
@@ -1629,7 +1681,7 @@ impl Evaluator {
                     return Ok(Value::Null);
                 }
                 let key = match prop {
-                    MemberProp::Name(n) => Arc::clone(n),
+                    MemberProp::Name { name, .. } => Arc::clone(name),
                     MemberProp::Expr(e) => {
                         let v = self.eval_expr(e)?;
                         match v {
@@ -1750,7 +1802,9 @@ impl Evaluator {
                     Value::Serve
                     | Value::PromiseResolver(_)
                     | Value::PromiseConstructor
-                    | Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => "function".into(),
+                    | Value::BoundPromiseMethod(_, _) => "function".into(),
+                    #[cfg(feature = "timers")]
+                    Value::TimerBuiltin(_) => "function".into(),
                     #[cfg(feature = "http")]
                     Value::Promise(_) => "object".into(),
                     #[cfg(feature = "regex")]
@@ -2291,7 +2345,7 @@ impl Evaluator {
         _optional: bool,
     ) -> Option<Result<Value, EvalError>> {
         match property {
-            MemberProp::Name(name) => match obj {
+            MemberProp::Name { name, .. } => match obj {
                 Value::Object(o) => {
                     let result = o
                         .borrow()
@@ -2323,8 +2377,9 @@ impl Evaluator {
             #[cfg(feature = "http")]
             Value::PromiseConstructor
             | Value::Serve
-            | Value::BoundPromiseMethod(_, _)
-            | Value::TimerBuiltin(_) => self.call_func(callee, args),
+            | Value::BoundPromiseMethod(_, _) => self.call_func(callee, args),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => self.call_func(callee, args),
             Value::OpaqueMethod(_, _) => self.call_func(callee, args),
             _ => Ok(Value::Null),
         }
@@ -2411,7 +2466,7 @@ impl Evaluator {
             Value::BoundPromiseMethod(promise_ref, method) => {
                 self.run_promise_method(promise_ref, method.as_ref(), args)
             }
-            #[cfg(feature = "http")]
+            #[cfg(feature = "timers")]
             Value::TimerBuiltin(name) => self.run_timer_builtin(name.as_ref(), args),
             Value::OpaqueMethod(opaque, method_name) => {
                 let method = opaque.get_method(method_name.as_ref()).ok_or_else(|| {
@@ -2629,7 +2684,7 @@ impl Evaluator {
         Ok(promise)
     }
 
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     fn run_timer_builtin(&self, name: &str, args: &[Value]) -> Result<Value, EvalError> {
         let callback = args
             .first()
@@ -2650,7 +2705,7 @@ impl Evaluator {
         Ok(Value::Number(id as f64))
     }
 
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     fn clear_timeout_native(args: &[Value]) -> Result<Value, String> {
         if let Some(Value::Number(n)) = args.first() {
             crate::timers::clearTimer(*n as u64);
@@ -2658,7 +2713,7 @@ impl Evaluator {
         Ok(Value::Null)
     }
 
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     fn clear_interval_native(args: &[Value]) -> Result<Value, String> {
         if let Some(Value::Number(n)) = args.first() {
             crate::timers::clearTimer(*n as u64);
@@ -2668,7 +2723,7 @@ impl Evaluator {
 
     /// Run all due timer callbacks. Called after the script completes so setTimeout/setInterval
     /// callbacks run without blocking the main script. Loops until no timers are due.
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     pub fn run_timer_phase(&mut self) -> Result<(), String> {
         const MAX_ITERATIONS: u32 = 1_000_000; // avoid infinite loop if setInterval never cleared
         let mut iterations = 0;
@@ -2760,8 +2815,14 @@ impl Evaluator {
                 }
             };
 
-            let (status, headers, body) = crate::http::value_to_response(&response_value);
-            crate::http::send_response(request, status, headers, body);
+            if let Some((status, headers, file_path)) =
+                crate::http::extract_file_from_response(&response_value)
+            {
+                crate::http::send_file_response(request, status, headers, file_path);
+            } else {
+                let (status, headers, body) = crate::http::value_to_response(&response_value);
+                crate::http::send_response(request, status, headers, body);
+            }
             count += 1;
             if max_requests.map(|m| count >= m).unwrap_or(false) {
                 break;
@@ -2809,7 +2870,7 @@ impl Evaluator {
                 for (i, elem) in elements.iter().enumerate() {
                     if let Some(el) = elem {
                         match el {
-                            tishlang_ast::DestructElement::Ident(name) => {
+                            tishlang_ast::DestructElement::Ident(name, _) => {
                                 let val = arr.get(i).cloned().unwrap_or(Value::Null);
                                 scope.borrow_mut().set(Arc::clone(name), val, mutable);
                             }
@@ -2817,7 +2878,7 @@ impl Evaluator {
                                 let val = arr.get(i).cloned().unwrap_or(Value::Null);
                                 Self::bind_destruct_pattern_scoped(scope, nested, &val, mutable)?;
                             }
-                            tishlang_ast::DestructElement::Rest(name) => {
+                            tishlang_ast::DestructElement::Rest(name, _) => {
                                 let rest: Vec<Value> = arr.iter().skip(i).cloned().collect();
                                 scope.borrow_mut().set(
                                     Arc::clone(name),
@@ -2843,13 +2904,13 @@ impl Evaluator {
                 for prop in props {
                     let val = obj.get(&prop.key).cloned().unwrap_or(Value::Null);
                     match &prop.value {
-                        tishlang_ast::DestructElement::Ident(name) => {
+                        tishlang_ast::DestructElement::Ident(name, _) => {
                             scope.borrow_mut().set(Arc::clone(name), val, mutable);
                         }
                         tishlang_ast::DestructElement::Pattern(nested) => {
                             Self::bind_destruct_pattern_scoped(scope, nested, &val, mutable)?;
                         }
-                        tishlang_ast::DestructElement::Rest(_) => {
+                        tishlang_ast::DestructElement::Rest(_, _) => {
                             return Err(EvalError::Error(
                                 "Rest not supported in object destructuring".to_string(),
                             ));
@@ -3240,8 +3301,9 @@ impl Evaluator {
             | Value::Promise(_)
             | Value::PromiseResolver(_)
             | Value::PromiseConstructor
-            | Value::BoundPromiseMethod(_, _)
-            | Value::TimerBuiltin(_) => "null".to_string(),
+            | Value::BoundPromiseMethod(_, _) => "null".to_string(),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => "null".to_string(),
             #[cfg(feature = "regex")]
             Value::RegExp(_) => "null".to_string(),
             Value::Opaque(_) | Value::OpaqueMethod(_, _) => "null".to_string(),

package/crates/tish_eval/src/http.rs

@@ -1,6 +1,7 @@
 //! HTTP server for the Tish interpreter. Client `fetch` uses `tishlang_runtime` from eval.
 
 use crate::value::{PropMap, Value};
+use std::fs::File;
 use std::sync::Arc;
 
 use tokio::runtime::Runtime;
@@ -101,6 +102,66 @@ pub fn value_to_response(value: &Value) -> (u16, Vec<(String, String)>, String)
     (status, headers, body)
 }
 
+/// If the response value has a `file` key, stream that path (binary-safe). Matches `tishlang_runtime` HTTP behavior.
+pub(crate) fn extract_file_from_response(value: &Value) -> Option<(u16, Vec<(String, String)>, String)> {
+    let Value::Object(obj) = value else {
+        return None;
+    };
+    let obj_ref = obj.borrow();
+    let file_val = obj_ref.get(&Arc::from("file"))?;
+    let Value::String(file_path) = file_val else {
+        return None;
+    };
+    let file_path = file_path.to_string();
+    let status = obj_ref
+        .get(&Arc::from("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"))
+        .and_then(|v| match v {
+            Value::Object(h) => Some(
+                h.borrow()
+                    .iter()
+                    .map(|(k, v)| (k.to_string(), v.to_string()))
+                    .collect(),
+            ),
+            _ => None,
+        })
+        .unwrap_or_default();
+    Some((status, headers, file_path))
+}
+
+pub(crate) fn send_file_response(
+    request: tiny_http::Request,
+    status: u16,
+    headers: Vec<(String, String)>,
+    file_path: String,
+) {
+    let file = match File::open(&file_path) {
+        Ok(f) => f,
+        Err(e) => {
+            eprintln!("Failed to open file {}: {}", file_path, e);
+            let fallback =
+                tiny_http::Response::from_string(format!("File not found: {}", file_path))
+                    .with_status_code(tiny_http::StatusCode(500));
+            let _ = request.respond(fallback);
+            return;
+        }
+    };
+    let status_code = tiny_http::StatusCode(status);
+    let mut response = tiny_http::Response::from_file(file).with_status_code(status_code);
+    for (key, value) in headers {
+        if let Ok(header) = tiny_http::Header::from_bytes(key.as_bytes(), value.as_bytes()) {
+            response = response.with_header(header);
+        }
+    }
+    let _ = request.respond(response);
+}
+
 /// Send a response using tiny_http.
 pub fn send_response(
     request: tiny_http::Request,

package/crates/tish_eval/src/lib.rs

@@ -8,7 +8,7 @@ mod natives;
 mod promise;
 #[cfg(feature = "regex")]
 pub mod regex;
-#[cfg(feature = "http")]
+#[cfg(feature = "timers")]
 mod timers;
 mod value;
 pub mod value_convert;
@@ -36,7 +36,7 @@ pub fn run(source: &str) -> Result<Value, String> {
     let program = tishlang_parser::parse(source)?;
     let mut eval = Evaluator::new();
     let result = eval.eval_program(&program)?;
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     eval.run_timer_phase()?;
     Ok(result)
 }
@@ -64,7 +64,7 @@ pub fn run_file(
     let mut eval = Evaluator::new();
     eval.set_current_dir(project_root.or(path.parent()));
     let result = eval.eval_program(&program)?;
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     eval.run_timer_phase()?;
     Ok(result)
 }

package/crates/tish_eval/src/natives.rs

@@ -115,6 +115,47 @@ pub fn encode_uri(args: &[Value]) -> Result<Value, String> {
     Ok(Value::String(tishlang_core::percent_encode(&s).into()))
 }
 
+pub fn html_escape(args: &[Value]) -> Result<Value, String> {
+    let input = match args.first() {
+        Some(Value::String(s)) => s.to_string(),
+        Some(v) => v.to_string(),
+        None => return Ok(Value::Null),
+    };
+    let bytes = input.as_bytes();
+    let mut extra = 0usize;
+    for b in bytes {
+        match b {
+            b'&' => extra += 4,
+            b'<' | b'>' => extra += 3,
+            b'"' => extra += 5,
+            b'\'' => extra += 4,
+            _ => {}
+        }
+    }
+    if extra == 0 {
+        return Ok(Value::String(input.into()));
+    }
+    let mut out = String::with_capacity(input.len() + extra);
+    let mut last = 0usize;
+    for (i, b) in bytes.iter().enumerate() {
+        let repl: Option<&'static str> = match b {
+            b'&' => Some("&amp;"),
+            b'<' => Some("&lt;"),
+            b'>' => Some("&gt;"),
+            b'"' => Some("&quot;"),
+            b'\'' => Some("&#39;"),
+            _ => None,
+        };
+        if let Some(r) = repl {
+            out.push_str(&input[last..i]);
+            out.push_str(r);
+            last = i + 1;
+        }
+    }
+    out.push_str(&input[last..]);
+    Ok(Value::String(out.into()))
+}
+
 pub fn math_abs(args: &[Value]) -> Result<Value, String> {
     Ok(Value::Number(
         get_num(args.first().unwrap_or(&Value::Null)).abs(),

package/crates/tish_eval/src/value.rs

@@ -61,7 +61,7 @@ pub enum Value {
     #[cfg(feature = "http")]
     BoundPromiseMethod(crate::promise::PromiseRef, std::sync::Arc<str>),
     /// Timer builtins: setTimeout, setInterval. Need evaluator for callback.
-    #[cfg(feature = "http")]
+    #[cfg(feature = "timers")]
     TimerBuiltin(std::sync::Arc<str>),
     /// Native `tishlang_core` Promise (fetch / reader.read / response.text).
     #[cfg(feature = "http")]
@@ -101,7 +101,9 @@ impl std::fmt::Debug for Value {
             #[cfg(feature = "http")]
             Value::PromiseConstructor => write!(f, "[Function: Promise]"),
             #[cfg(feature = "http")]
-            Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            Value::BoundPromiseMethod(_, _) => write!(f, "[Function]"),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "Promise"),
             Value::CoreFn(_) => write!(f, "CoreFn"),
@@ -156,7 +158,9 @@ impl std::fmt::Display for Value {
             #[cfg(feature = "http")]
             Value::PromiseConstructor => write!(f, "function Promise() {{ [native code] }}"),
             #[cfg(feature = "http")]
-            Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
+            Value::BoundPromiseMethod(_, _) => write!(f, "[Function]"),
+            #[cfg(feature = "timers")]
+            Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "[Promise]"),
             Value::CoreFn(_) => write!(f, "[Function]"),