@tishlang/tish-format 1.0.13 → 2.0.1

package/crates/tish_eval/src/eval.rs

@@ -21,25 +21,32 @@ use crate::value::{
     eval_object_get, eval_object_has, eval_object_set, EvalObjectData, PropMap, Value,
 };
 
-struct Scope {
-    vars: PropMap,
-    consts: std::collections::HashSet<Arc<str>>,
+pub struct Scope {
+    // Scope vars: order is never observed (no Object.keys over a scope), so use a fast
+    // unordered aHash map — NOT the object-strings PropMap (an insertion-ordered IndexMap),
+    // which would pay SipHash + ordered-bucket overhead on every variable lookup.
+    vars: AHashMap<Arc<str>, Value>,
+    consts: ahash::AHashSet<Arc<str>>,
     parent: Option<Rc<std::cell::RefCell<Scope>>>,
 }
 
+/// A reference-counted lexical scope. A `Value::Function` captures one of these at creation
+/// (the *defining* scope) so calls resolve free variables lexically — real closures.
+pub type ScopeRef = Rc<std::cell::RefCell<Scope>>;
+
 impl Scope {
     fn new() -> Rc<std::cell::RefCell<Self>> {
         Rc::new(std::cell::RefCell::new(Self {
-            vars: PropMap::default(),
-            consts: std::collections::HashSet::new(),
+            vars: AHashMap::default(),
+            consts: ahash::AHashSet::default(),
             parent: None,
         }))
     }
 
     fn child(parent: Rc<std::cell::RefCell<Scope>>) -> Rc<std::cell::RefCell<Self>> {
         Rc::new(std::cell::RefCell::new(Self {
-            vars: PropMap::default(),
-            consts: std::collections::HashSet::new(),
+            vars: AHashMap::default(),
+            consts: ahash::AHashSet::default(),
             parent: Some(parent),
         }))
     }
@@ -144,6 +151,15 @@ impl Evaluator {
             math.insert("exp".into(), Value::Native(natives::math_exp));
             math.insert("sign".into(), Value::Native(natives::math_sign));
             math.insert("trunc".into(), Value::Native(natives::math_trunc));
+            math.insert("sinh".into(), Value::Native(natives::math_sinh));
+            math.insert("cosh".into(), Value::Native(natives::math_cosh));
+            math.insert("tanh".into(), Value::Native(natives::math_tanh));
+            math.insert("asinh".into(), Value::Native(natives::math_asinh));
+            math.insert("acosh".into(), Value::Native(natives::math_acosh));
+            math.insert("atanh".into(), Value::Native(natives::math_atanh));
+            math.insert("cbrt".into(), Value::Native(natives::math_cbrt));
+            math.insert("log2".into(), Value::Native(natives::math_log2));
+            math.insert("log10".into(), Value::Native(natives::math_log10));
             math.insert("PI".into(), Value::Number(std::f64::consts::PI));
             math.insert("E".into(), Value::Number(std::f64::consts::E));
             s.set(
@@ -179,45 +195,95 @@ impl Evaluator {
                 true,
             );
 
-            let mut array_obj = PropMap::with_capacity(1);
+            let mut array_obj = PropMap::with_capacity(3);
             array_obj.insert("isArray".into(), Value::Native(natives::array_is_array));
+            // `Array(n)` and `new Array(n)` constructor (issue #72).
+            array_obj.insert("__call".into(), Value::Native(natives::array_construct));
+            array_obj.insert("__construct".into(), Value::Native(natives::array_construct));
             s.set(
                 "Array".into(),
                 Value::object(array_obj),
                 true,
             );
 
-            let mut string_obj = PropMap::with_capacity(1);
+            // Error constructors (issue #60): callable + constructable via __call/__construct.
+            for (name, ctor) in [
+                ("Error", natives::error_construct as fn(&[Value]) -> Result<Value, String>),
+                ("TypeError", natives::type_error_construct),
+                ("RangeError", natives::range_error_construct),
+                ("SyntaxError", natives::syntax_error_construct),
+            ] {
+                let mut err_obj = PropMap::with_capacity(2);
+                err_obj.insert("__call".into(), Value::Native(ctor));
+                err_obj.insert("__construct".into(), Value::Native(ctor));
+                s.set(name.into(), Value::object(err_obj), true);
+            }
+
+            let mut string_obj = PropMap::with_capacity(2);
             string_obj.insert(
                 "fromCharCode".into(),
                 Value::Native(natives::string_from_char_code),
             );
+            // `String(value)` callable: dispatched via `__call` in `call_func`, like `Symbol`.
+            string_obj.insert("__call".into(), Value::Native(natives::string_convert));
             s.set(
                 "String".into(),
                 Value::object(string_obj),
                 true,
             );
 
-            let mut date = PropMap::with_capacity(1);
-            date.insert("now".into(), Value::Native(natives::date_now));
+            // `Number(value)` coercion as a callable global (issue #36).
+            let mut number_obj = PropMap::with_capacity(1);
+            number_obj.insert("__call".into(), Value::Native(natives::number_convert));
+            s.set("Number".into(), Value::object(number_obj), true);
+
             s.set(
                 "Date".into(),
-                Value::object(date),
+                crate::value_convert::core_to_eval(
+                    tishlang_builtins::date::date_constructor_value(),
+                ),
                 true,
             );
-
             s.set(
-                "Symbol".into(),
-                crate::value_convert::core_to_eval(tishlang_builtins::symbol::symbol_object()),
+                "Set".into(),
+                crate::value_convert::core_to_eval(
+                    tishlang_builtins::collections::set_constructor_value(),
+                ),
                 true,
             );
             s.set(
-                "Uint8Array".into(),
+                "Map".into(),
                 crate::value_convert::core_to_eval(
-                    tishlang_builtins::construct::uint8_array_constructor_value(),
+                    tishlang_builtins::collections::map_constructor_value(),
                 ),
                 true,
             );
+
+            s.set(
+                "Symbol".into(),
+                crate::value_convert::core_to_eval(tishlang_builtins::symbol::symbol_object()),
+                true,
+            );
+            for (name, ctor) in [
+                (
+                    "Float64Array",
+                    tishlang_builtins::typedarrays::float64_array_constructor_value
+                        as fn() -> tishlang_core::Value,
+                ),
+                ("Float32Array", tishlang_builtins::typedarrays::float32_array_constructor_value),
+                ("Int8Array", tishlang_builtins::typedarrays::int8_array_constructor_value),
+                ("Uint8Array", tishlang_builtins::typedarrays::uint8_array_constructor_value),
+                (
+                    "Uint8ClampedArray",
+                    tishlang_builtins::typedarrays::uint8_clamped_array_constructor_value,
+                ),
+                ("Int16Array", tishlang_builtins::typedarrays::int16_array_constructor_value),
+                ("Uint16Array", tishlang_builtins::typedarrays::uint16_array_constructor_value),
+                ("Int32Array", tishlang_builtins::typedarrays::int32_array_constructor_value),
+                ("Uint32Array", tishlang_builtins::typedarrays::uint32_array_constructor_value),
+            ] {
+                s.set(name.into(), crate::value_convert::core_to_eval(ctor()), true);
+            }
             s.set(
                 "AudioContext".into(),
                 crate::value_convert::core_to_eval(
@@ -325,6 +391,15 @@ impl Evaluator {
                 self.scope = prev;
                 Ok(last)
             }
+            // Comma-declarators: a transparent group — evaluate each declarator in
+            // the *current* scope (no child scope).
+            Statement::Multi { statements, .. } => {
+                let mut last = Value::Null;
+                for s in statements {
+                    last = self.eval_statement(s)?;
+                }
+                Ok(last)
+            }
             Statement::VarDecl {
                 name,
                 mutable,
@@ -396,23 +471,40 @@ impl Evaluator {
                         .chars()
                         .map(|c| crate::value::Value::String(Arc::from(c.to_string())))
                         .collect::<Vec<_>>(),
-                    _ => {
-                        return Err(EvalError::Error(format!(
-                            "for-of requires iterable (array or string), got {}",
-                            iter_val
-                        )));
-                    }
+                    // Iterator protocol: an object with a callable `next()` returning
+                    // `{ value, done }` — e.g. a Map/Set iterator from `.values()` /
+                    // `.keys()` / `.entries()`. Drain it ONCE (draining advances the
+                    // iterator's shared position, so it must not be re-run).
+                    _ => match self.drain_eval_iterator(&iter_val) {
+                        Some(elems) => elems,
+                        None => {
+                            return Err(EvalError::Error(format!(
+                                "for-of requires iterable (array, string, or iterator), got {}",
+                                iter_val
+                            )));
+                        }
+                    },
                 };
+                // Each element gets a FRESH per-iteration binding (ES6 `for (let v of …)`), so a
+                // closure created in the body captures that element, not the last one.
+                let outer = Rc::clone(&self.scope);
+                let mut ret = Ok(Value::Null);
                 for elem in elements {
-                    self.scope.borrow_mut().set(Arc::clone(name), elem, true);
+                    let iter_env = Scope::child(Rc::clone(&outer));
+                    iter_env.borrow_mut().set(Arc::clone(name), elem, true);
+                    self.scope = Rc::clone(&iter_env);
                     match self.eval_statement(body) {
                         Ok(_) => {}
                         Err(EvalError::Break) => break,
                         Err(EvalError::Continue) => continue,
-                        Err(e) => return Err(e),
+                        Err(e) => {
+                            ret = Err(e);
+                            break;
+                        }
                     }
                 }
-                Ok(Value::Null)
+                self.scope = outer;
+                ret
             }
             Statement::For {
                 init,
@@ -421,34 +513,76 @@ impl Evaluator {
                 body,
                 ..
             } => {
+                // `let`/`const` declared in `init` get a FRESH per-iteration binding (ES6), so a
+                // closure created in the body captures THAT iteration's value, not the final one.
+                // The canonical values live in `loop_env`; each iteration's body runs in a fresh
+                // `iter_env` copy, and mutations are copied back for the next test/update.
+                let outer = Rc::clone(&self.scope);
+                let loop_env = Scope::child(Rc::clone(&outer));
+                self.scope = Rc::clone(&loop_env);
                 if let Some(i) = init {
-                    self.eval_statement(i)?;
+                    if let Err(e) = self.eval_statement(i) {
+                        self.scope = outer;
+                        return Err(e);
+                    }
                 }
+                let per_iter: Vec<Arc<str>> = loop_env.borrow().vars.keys().cloned().collect();
+                let copy_vars = |from: &ScopeRef, to: &ScopeRef, names: &[Arc<str>]| {
+                    let src = from.borrow();
+                    let mut dst = to.borrow_mut();
+                    for n in names {
+                        if let Some(v) = src.vars.get(n.as_ref()) {
+                            dst.set(Arc::clone(n), v.clone(), true);
+                        }
+                    }
+                };
+                let mut ret = Ok(Value::Null);
                 loop {
-                    let cond_ok = cond
-                        .as_ref()
-                        .map(|c| self.eval_expr(c).map(|v| v.is_truthy()))
-                        .transpose()?
-                        .unwrap_or(true);
+                    self.scope = Rc::clone(&loop_env);
+                    let cond_ok = match cond.as_ref() {
+                        Some(c) => match self.eval_expr(c) {
+                            Ok(v) => v.is_truthy(),
+                            Err(e) => {
+                                ret = Err(e);
+                                break;
+                            }
+                        },
+                        None => true,
+                    };
                     if !cond_ok {
                         break;
                     }
-                    match self.eval_statement(body) {
+                    let iter_env = if per_iter.is_empty() {
+                        Rc::clone(&loop_env)
+                    } else {
+                        let e = Scope::child(Rc::clone(&outer));
+                        copy_vars(&loop_env, &e, &per_iter);
+                        e
+                    };
+                    self.scope = Rc::clone(&iter_env);
+                    let flow = self.eval_statement(body);
+                    if !per_iter.is_empty() {
+                        copy_vars(&iter_env, &loop_env, &per_iter);
+                    }
+                    match flow {
                         Ok(_) => {}
                         Err(EvalError::Break) => break,
-                        Err(EvalError::Continue) => {
-                            if let Some(u) = update {
-                                self.eval_expr(u)?;
-                            }
-                            continue;
+                        Err(EvalError::Continue) => {}
+                        Err(e) => {
+                            ret = Err(e);
+                            break;
                         }
-                        Err(e) => return Err(e),
                     }
+                    self.scope = Rc::clone(&loop_env);
                     if let Some(u) = update {
-                        self.eval_expr(u)?;
+                        if let Err(e) = self.eval_expr(u) {
+                            ret = Err(e);
+                            break;
+                        }
                     }
                 }
-                Ok(Value::Null)
+                self.scope = outer;
+                ret
             }
             Statement::Return { value, .. } => {
                 let v = value
@@ -474,6 +608,9 @@ impl Evaluator {
                     formals,
                     rest_param: rest_param_name,
                     body,
+                    // Capture the defining scope. It's the SAME Rc we insert into below, so the
+                    // function sees itself → recursion works.
+                    env: Rc::clone(&self.scope),
                 };
                 self.scope.borrow_mut().set(Arc::clone(name), func, true);
                 Ok(Value::Null)
@@ -562,9 +699,22 @@ impl Evaluator {
             } => {
                 let try_result = self.eval_statement(body);
 
-                let result = match try_result {
-                    Ok(v) => Ok(v),
-                    Err(EvalError::Throw(thrown)) => {
+                // Both a user `throw` and a runtime error (`null.foo()`, "not a function", …)
+                // are catchable (issue #60); a runtime error is boxed as a `{ name, message }`
+                // object so `catch (e) { e.message }` works. Break/Continue/Return propagate.
+                let caught: Option<Value> = match &try_result {
+                    Err(EvalError::Throw(v)) => Some(v.clone()),
+                    Err(EvalError::Error(msg)) => {
+                        let mut m = crate::value::PropMap::with_capacity(2);
+                        m.insert("name".into(), Value::String("TypeError".into()));
+                        m.insert("message".into(), Value::String(msg.as_str().into()));
+                        Some(Value::object(m))
+                    }
+                    _ => None,
+                };
+
+                let result = match caught {
+                    Some(thrown) => {
                         if let Some(catch_stmt) = catch_body {
                             if let Some(param) = catch_param {
                                 let scope = Scope::child(Rc::clone(&self.scope));
@@ -577,13 +727,20 @@ impl Evaluator {
                                 self.eval_statement(catch_stmt)
                             }
                         } else {
-                            Err(EvalError::Throw(thrown))
+                            // No catch clause — re-raise the original error after `finally`.
+                            try_result
                         }
                     }
-                    Err(e) => Err(e),
+                    None => try_result,
                 };
 
                 if let Some(finally_stmt) = finally_body {
+                    // KNOWN BUG (shared with the VM/compiled backends): a throw/return/
+                    // break/continue inside `finally` should supersede the try/catch
+                    // outcome (JS completion semantics) but is swallowed here. Fixing it
+                    // in the interp alone (`?`) breaks interp==vm parity because the VM has
+                    // the same bug, and the VM fix is a bytecode-compiler-level
+                    // finally-completion change. Deferred as a coordinated cross-backend fix.
                     let _ = self.eval_statement(finally_stmt);
                 }
 
@@ -760,7 +917,7 @@ impl Evaluator {
                     exports.insert("isDir".into(), Value::Native(natives::is_dir));
                     exports.insert("readDir".into(), Value::Native(natives::read_dir));
                     exports.insert("mkdir".into(), Value::Native(natives::mkdir));
-                    return Ok(Value::object(exports));
+                    Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "fs"))]
                 {
@@ -777,7 +934,7 @@ 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(exports));
+                    Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "http"))]
                 {
@@ -806,7 +963,7 @@ impl Evaluator {
                         "clearInterval".into(),
                         Value::Native(Self::clear_interval_native),
                     );
-                    return Ok(Value::object(exports));
+                    Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "timers"))]
                 {
@@ -829,7 +986,7 @@ impl Evaluator {
                         "wsBroadcast".into(),
                         Value::Native(Self::ws_broadcast_native),
                     );
-                    return Ok(Value::object(exports));
+                    Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "ws"))]
                 {
@@ -838,6 +995,32 @@ impl Evaluator {
                     ));
                 }
             }
+            "tish:tty" => {
+                #[cfg(feature = "tty")]
+                {
+                    let mut exports: PropMap = PropMap::default();
+                    exports.insert("size".into(), Value::Native(natives::tty_size));
+                    exports.insert("isTTY".into(), Value::Native(natives::tty_is_tty));
+                    exports.insert("setRawMode".into(), Value::Native(natives::tty_set_raw_mode));
+                    exports.insert(
+                        "enterAltScreen".into(),
+                        Value::Native(natives::tty_enter_alt_screen),
+                    );
+                    exports.insert(
+                        "leaveAltScreen".into(),
+                        Value::Native(natives::tty_leave_alt_screen),
+                    );
+                    exports.insert("read".into(), Value::Native(natives::tty_read));
+                    exports.insert("readLine".into(), Value::Native(natives::tty_read_line));
+                    Ok(Value::object(exports))
+                }
+                #[cfg(not(feature = "tty"))]
+                {
+                    return Err(EvalError::Error(
+                        "tish:tty requires the tty feature. Rebuild with: cargo build -p tishlang --features tty".into(),
+                    ));
+                }
+            }
             "tish:process" => {
                 #[cfg(feature = "process")]
                 {
@@ -868,7 +1051,7 @@ impl Evaluator {
                         "process".into(),
                         Value::object(process_obj),
                     );
-                    return Ok(Value::object(exports));
+                    Ok(Value::object(exports))
                 }
                 #[cfg(not(feature = "process"))]
                 {
@@ -878,10 +1061,10 @@ impl Evaluator {
                 }
             }
             _ => {
-                return Err(EvalError::Error(format!(
+                Err(EvalError::Error(format!(
                     "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:timers, tish:process, tish:ws (plus any registered by native modules)",
                     spec
-                )));
+                )))
             }
         }
     }
@@ -998,13 +1181,45 @@ impl Evaluator {
                                     _ => ",".to_string(),
                                 };
                                 let arr_borrow = arr.borrow();
-                                let parts: Vec<String> = arr_borrow.iter().map(|v| v.to_string()).collect();
+                                // JS join: null/undefined → "", else JS ToString (nested arrays
+                                // recurse to a comma-join, objects → "[object Object]").
+                                let parts: Vec<String> = arr_borrow
+                                    .iter()
+                                    .map(|v| match v {
+                                        Value::Null => String::new(),
+                                        other => other.to_js_string(),
+                                    })
+                                    .collect();
                                 return Ok(Value::String(parts.join(&sep).into()));
                             }
                             "reverse" => {
                                 arr.borrow_mut().reverse();
                                 return Ok(obj.clone());
                             }
+                            "fill" => {
+                                // Array.prototype.fill(value, start?, end?) — in place (issue #76).
+                                let value = arg_vals.first().cloned().unwrap_or(Value::Null);
+                                let mut arr_mut = arr.borrow_mut();
+                                let len = arr_mut.len() as i64;
+                                let norm = |v: Option<&Value>, dflt: usize| -> usize {
+                                    match v {
+                                        Some(Value::Number(n)) => {
+                                            let n = *n as i64;
+                                            if n < 0 { (len + n).max(0) as usize } else { (n as usize).min(len as usize) }
+                                        }
+                                        _ => dflt,
+                                    }
+                                };
+                                let start = norm(arg_vals.get(1), 0);
+                                let end = norm(arg_vals.get(2), len as usize);
+                                let mut i = start;
+                                while i < end && i < arr_mut.len() {
+                                    arr_mut[i] = value.clone();
+                                    i += 1;
+                                }
+                                drop(arr_mut);
+                                return Ok(obj.clone());
+                            }
                             "shuffle" => {
                                 let mut v = arr.borrow().clone();
                                 use rand::seq::SliceRandom;
@@ -1652,6 +1867,24 @@ impl Evaluator {
                             let formatted = format!("{:.*}", digits as usize, n);
                             return Ok(Value::String(formatted.into()));
                         }
+                        if method_name.as_ref() == "toString" {
+                            // Shares the VM/native formatting via the backend-agnostic helper
+                            // (issue #59). Radix defaults to 10; 2–36 supported, else RangeError.
+                            let radix = arg_vals
+                                .first()
+                                .and_then(|v| match v {
+                                    Value::Number(d) => Some(*d as i64),
+                                    _ => None,
+                                })
+                                .unwrap_or(10);
+                            return match tishlang_builtins::number::number_to_string_radix(*n, radix)
+                            {
+                                Some(s) => Ok(Value::String(s.into())),
+                                None => Err(EvalError::Error(
+                                    "toString() radix must be between 2 and 36".to_string(),
+                                )),
+                            };
+                        }
                     }
 
                     // RegExp methods
@@ -1759,8 +1992,11 @@ impl Evaluator {
                         }
                         tishlang_ast::ArrayElement::Spread(e) => {
                             let spread_val = self.eval_expr(e)?;
-                            if let Value::Array(arr) = spread_val {
+                            if let Value::Array(arr) = &spread_val {
                                 vals.extend(arr.borrow().iter().cloned());
+                            } else if let Some(items) = self.drain_eval_iterator(&spread_val) {
+                                // Spread a Map/Set iterator (`[...m.values()]`).
+                                vals.extend(items);
                             }
                         }
                     }
@@ -1847,6 +2083,52 @@ impl Evaluator {
                     Value::OpaqueMethod(_, _) => "function".into(),
                 }))
             }
+            // `delete obj.prop` / `delete obj[key]` (issue #40): remove the property and
+            // evaluate to `true`. Objects drop the key; arrays clear a numeric index to a
+            // null hole (length preserved). Deleting a non-reference is a no-op (still `true`).
+            Expr::Delete { target, .. } => {
+                // Resolve the target to (object value, key value); then remove the key.
+                let resolved = match target.as_ref() {
+                    Expr::Member { object, prop: MemberProp::Name { name, .. }, .. } => {
+                        Some((self.eval_expr(object)?, Value::String(name.as_ref().into())))
+                    }
+                    Expr::Member { object, prop: MemberProp::Expr(key), .. } => {
+                        Some((self.eval_expr(object)?, self.eval_expr(key)?))
+                    }
+                    Expr::Index { object, index, .. } => {
+                        Some((self.eval_expr(object)?, self.eval_expr(index)?))
+                    }
+                    _ => None,
+                };
+                if let Some((obj, key)) = resolved {
+                    match &obj {
+                        Value::Object(map) => {
+                            let key_s = match &key {
+                                Value::String(s) => s.to_string(),
+                                Value::Number(n) => n.to_string(),
+                                other => other.to_string(),
+                            };
+                            // shift_remove preserves the insertion order of the remaining keys
+                            // (JS delete semantics); plain remove() is deprecated on IndexMap.
+                            map.borrow_mut().strings.shift_remove(key_s.as_str());
+                        }
+                        Value::Array(arr) => {
+                            if let Value::Number(n) = &key {
+                                let n = *n;
+                                if n >= 0.0 && n.fract() == 0.0 {
+                                    let i = n as usize;
+                                    let mut a = arr.borrow_mut();
+                                    if i < a.len() {
+                                        a[i] = Value::Null;
+                                    }
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+                Ok(Value::Bool(true))
+            }
             Expr::PostfixInc { name, .. } => {
                 let v = self.scope.borrow().get(name.as_ref())
                     .ok_or_else(|| EvalError::Error(format!("Undefined variable: {}", name)))?;
@@ -1963,6 +2245,19 @@ impl Evaluator {
                             .insert(Arc::clone(prop), val.clone());
                         Ok(val)
                     }
+                    // `arr.length = k` truncates / grows the array (holes read back as Null),
+                    // matching JS and the bytecode VM (issue #62).
+                    Value::Array(arr) if prop.as_ref() == "length" => {
+                        let n = match &val {
+                            Value::Number(n) => *n,
+                            _ => f64::NAN,
+                        };
+                        if n.is_nan() || n < 0.0 || n.fract() != 0.0 || n > 4_294_967_295.0 {
+                            return Err(EvalError::Error("Invalid array length".to_string()));
+                        }
+                        arr.borrow_mut().resize(n as usize, Value::Null);
+                        Ok(val)
+                    }
                     _ => Err(EvalError::Error(format!(
                         "Cannot assign property '{}' on non-object: {:?}",
                         prop, obj_val
@@ -2018,6 +2313,7 @@ impl Evaluator {
                     formals,
                     rest_param: None,
                     body: Arc::new(body_stmt),
+                    env: Rc::clone(&self.scope),
                 })
             }
             Expr::TemplateLiteral { quasis, exprs, .. } => {
@@ -2027,7 +2323,7 @@ impl Evaluator {
                     result.push_str(quasi);
                     if i < exprs.len() {
                         let val = self.eval_expr(&exprs[i])?;
-                        result.push_str(&val.to_string());
+                        result.push_str(&val.to_js_string());
                     }
                 }
                 Ok(Value::String(result.into()))
@@ -2046,20 +2342,26 @@ impl Evaluator {
                     Ok(Value::String(s.into()))
                 }
                 (Value::String(a), b) => {
-                    let b_str = b.to_string();
+                    let b_str = b.to_js_string();
                     let mut s = String::with_capacity(a.len() + b_str.len());
                     s.push_str(a);
                     s.push_str(&b_str);
                     Ok(Value::String(s.into()))
                 }
                 (a, Value::String(b)) => {
-                    let a_str = a.to_string();
+                    let a_str = a.to_js_string();
                     let mut s = String::with_capacity(a_str.len() + b.len());
                     s.push_str(&a_str);
                     s.push_str(b);
                     Ok(Value::String(s.into()))
                 }
-                _ => Err(format!("Cannot add {:?} and {:?}", l, r)),
+                // Neither operand is a string: numeric add, coercing non-numbers
+                // (Null/Bool/Object/…) to NaN exactly like the VM's
+                // `as_number().unwrap_or(NaN)` (vm.rs eval_binop). e.g. an out-of-bounds
+                // array read is `Null` (JS `undefined`), so `15 + arr[oob]` → NaN, not an error.
+                _ => Ok(Value::Number(
+                    l.as_number().unwrap_or(f64::NAN) + r.as_number().unwrap_or(f64::NAN),
+                )),
             },
             BinOp::Sub => self.binop_number(l, r, |a, b| Value::Number(a - b)),
             BinOp::Mul => self.binop_number(l, r, |a, b| Value::Number(a * b)),
@@ -2068,17 +2370,29 @@ impl Evaluator {
             BinOp::Pow => self.binop_number(l, r, |a, b| Value::Number(a.powf(b))),
             BinOp::StrictEq => Ok(Value::Bool(l.strict_eq(r))),
             BinOp::StrictNe => Ok(Value::Bool(!l.strict_eq(r))),
-            BinOp::Lt => self.binop_number(l, r, |a, b| Value::Bool(a < b)),
-            BinOp::Le => self.binop_number(l, r, |a, b| Value::Bool(a <= b)),
-            BinOp::Gt => self.binop_number(l, r, |a, b| Value::Bool(a > b)),
-            BinOp::Ge => self.binop_number(l, r, |a, b| Value::Bool(a >= b)),
+            // Relational ops compare strings lexicographically when BOTH operands
+            // are strings (JS semantics); otherwise coerce to numbers via binop_number.
+            BinOp::Lt => self.binop_relational(l, r, |o| o.is_lt()),
+            BinOp::Le => self.binop_relational(l, r, |o| o.is_le()),
+            BinOp::Gt => self.binop_relational(l, r, |o| o.is_gt()),
+            BinOp::Ge => self.binop_relational(l, r, |o| o.is_ge()),
             BinOp::And => Ok(Value::Bool(l.is_truthy() && r.is_truthy())),
             BinOp::Or => Ok(Value::Bool(l.is_truthy() || r.is_truthy())),
             BinOp::BitAnd => self.binop_int32(l, r, |a, b| Value::Number((a & b) as f64)),
             BinOp::BitOr => self.binop_int32(l, r, |a, b| Value::Number((a | b) as f64)),
             BinOp::BitXor => self.binop_int32(l, r, |a, b| Value::Number((a ^ b) as f64)),
-            BinOp::Shl => self.binop_int32(l, r, |a, b| Value::Number((a << b) as f64)),
-            BinOp::Shr => self.binop_int32(l, r, |a, b| Value::Number((a >> b) as f64)),
+            // JS shifts mask the count to the low 5 bits; `wrapping_sh*` does exactly
+            // that and never panics (plain `<<`/`>>` panic in debug for count >= 32).
+            BinOp::Shl => {
+                self.binop_int32(l, r, |a, b| Value::Number(a.wrapping_shl(b as u32) as f64))
+            }
+            BinOp::Shr => {
+                self.binop_int32(l, r, |a, b| Value::Number(a.wrapping_shr(b as u32) as f64))
+            }
+            // `>>>` — unsigned (logical) right shift: ToUint32(a) >>> (b & 31).
+            BinOp::UShr => self.binop_int32(l, r, |a, b| {
+                Value::Number((a as u32).wrapping_shr(b as u32) as f64)
+            }),
             BinOp::In => {
                 let ok = match r {
                     Value::Object(_) => eval_object_has(r, l),
@@ -2104,7 +2418,10 @@ impl Evaluator {
                 };
                 Ok(Value::Bool(ok))
             }
-            BinOp::Eq | BinOp::Ne => Err("Loose equality not supported".to_string()),
+            // Loose ==/!= : match the VM (vm.rs maps Eq/Ne to strict_eq) so interp == vm ==
+            // compiled. Previously the interpreter alone errored on `==`.
+            BinOp::Eq => Ok(Value::Bool(l.strict_eq(r))),
+            BinOp::Ne => Ok(Value::Bool(!l.strict_eq(r))),
         }
     }
 
@@ -2172,10 +2489,19 @@ impl Evaluator {
         false
     }
 
-    fn to_int32(v: &Value) -> Result<i32, String> {
-        match v {
-            Value::Number(n) => Ok(*n as i32),
-            _ => Err(format!("Bitwise operands must be numbers, got {:?}", v)),
+    /// JS ToInt32 coercion. Non-numbers coerce to NaN → 0. Going through `i64`
+    /// (not a direct `as i32`) gives modulo-2³² truncation instead of a saturating
+    /// cast, so out-of-i32-range values (e.g. a `0..2³²` hash) wrap exactly like JS:
+    /// `4294967295 | 0 === -1`, not the saturated `i32::MAX`. Realistic values are
+    /// `< 2⁵³` so they fit `i64` exactly; the two casts stay cheap.
+    fn to_int32(v: &Value) -> i32 {
+        // NaN / ±Infinity → 0 (the `is_finite` guard): `f64 as i64` *saturates* (`+∞ → i64::MAX
+        // → -1`), which is not the JS ToInt32 result. Finite values use the cheap modulo cast.
+        let x = v.as_number().unwrap_or(f64::NAN);
+        if x.is_finite() {
+            x as i64 as i32
+        } else {
+            0
         }
     }
 
@@ -2183,19 +2509,39 @@ impl Evaluator {
     where
         F: FnOnce(i32, i32) -> Value,
     {
-        let a = Self::to_int32(l)?;
-        let b = Self::to_int32(r)?;
-        Ok(f(a, b))
+        Ok(f(Self::to_int32(l), Self::to_int32(r)))
     }
 
+    /// Numeric binop, coercing each operand to a number the way the VM does
+    /// (`as_number().unwrap_or(NaN)`): non-numbers (Null/Bool/Object/…) become NaN rather
+    /// than erroring. Keeps the interpreter in parity with the VM and Node on out-of-bounds
+    /// reads and other `undefined`-like operands.
     fn binop_number<F>(&self, l: &Value, r: &Value, f: F) -> Result<Value, String>
     where
         F: FnOnce(f64, f64) -> Value,
     {
-        match (l, r) {
-            (Value::Number(a), Value::Number(b)) => Ok(f(*a, *b)),
-            _ => Err(format!("Expected numbers, got {:?} and {:?}", l, r)),
-        }
+        let a = l.as_number().unwrap_or(f64::NAN);
+        let b = r.as_number().unwrap_or(f64::NAN);
+        Ok(f(a, b))
+    }
+
+    /// Relational comparison (`<` `<=` `>` `>=`). When both operands are strings,
+    /// compare lexicographically; otherwise coerce to numbers. `pred` maps the
+    /// resulting `Ordering` to a bool. A NaN-involved numeric comparison yields no
+    /// ordering and is always `false`, matching JS (`NaN < 5` → false).
+    fn binop_relational<F>(&self, l: &Value, r: &Value, pred: F) -> Result<Value, String>
+    where
+        F: FnOnce(std::cmp::Ordering) -> bool,
+    {
+        let ord = match (l, r) {
+            (Value::String(a), Value::String(b)) => Some(a.as_ref().cmp(b.as_ref())),
+            _ => {
+                let a = l.as_number().unwrap_or(f64::NAN);
+                let b = r.as_number().unwrap_or(f64::NAN);
+                a.partial_cmp(&b)
+            }
+        };
+        Ok(Value::Bool(ord.map(pred).unwrap_or(false)))
     }
 
     fn eval_unary(&self, op: UnaryOp, v: &Value) -> Result<Value, String> {
@@ -2210,7 +2556,7 @@ impl Evaluator {
                 _ => Err(format!("Cannot apply unary + to {:?}", v)),
             },
             UnaryOp::BitNot => {
-                let n = Self::to_int32(v)?;
+                let n = Self::to_int32(v);
                 Ok(Value::Number((!n) as f64))
             }
             UnaryOp::Void => Ok(Value::Null),
@@ -2504,7 +2850,7 @@ impl Evaluator {
                     .map(crate::value_convert::eval_to_core)
                     .collect();
                 let ca = ca.map_err(EvalError::Error)?;
-                Ok(crate::value_convert::core_to_eval(f(&ca)))
+                Ok(crate::value_convert::core_to_eval(f.call(&ca)))
             }
             #[cfg(feature = "regex")]
             Value::RegExp(_) => Err(EvalError::Error("RegExp is not callable".to_string())),
@@ -2527,15 +2873,30 @@ impl Evaluator {
                     .map(crate::value_convert::eval_to_core)
                     .collect();
                 let core_args = core_args.map_err(EvalError::Error)?;
-                let result = method(&core_args);
+                let result = method.call(&core_args);
                 Ok(crate::value_convert::core_to_eval(result))
             }
             Value::Function {
                 formals,
                 rest_param,
                 body,
+                env,
             } => {
-                let scope = Scope::child(Rc::clone(&self.scope));
+                // A real closure: the call frame's parent is the function's DEFINING scope (env),
+                // not the call site — so free variables resolve lexically.
+                let scope = Scope::child(Rc::clone(env));
+                // The call-frame evaluator, built up front so default-parameter expressions
+                // evaluate in this *call* scope — where earlier params are already bound (so a
+                // default like `b = a + 1` can see `a`) and free vars still resolve lexically
+                // through the closure's `env`. Evaluating against `self.scope` (the call *site*)
+                // would see neither, matching the bytecode VM's ArgMissing prologue, which runs
+                // defaults in the frame after the supplied args are bound.
+                let mut eval = Evaluator {
+                    scope: Rc::clone(&scope),
+                    module_cache: Rc::clone(&self.module_cache),
+                    current_dir: RefCell::new(self.current_dir.borrow().clone()),
+                    virtual_builtins: Rc::clone(&self.virtual_builtins),
+                };
                 {
                     let mut s = scope.borrow_mut();
                     for (i, formal) in formals.iter().enumerate() {
@@ -2548,7 +2909,7 @@ impl Evaluator {
                                 };
                                 if let Some(default_expr) = def {
                                     drop(s);
-                                    let default_val = self.eval_expr(default_expr)?;
+                                    let default_val = eval.eval_expr(default_expr)?;
                                     s = scope.borrow_mut();
                                     default_val
                                 } else {
@@ -2577,13 +2938,33 @@ impl Evaluator {
                         );
                     }
                 }
-                let mut eval = Evaluator {
-                    scope,
-                    module_cache: Rc::clone(&self.module_cache),
-                    current_dir: RefCell::new(self.current_dir.borrow().clone()),
-                    virtual_builtins: Rc::clone(&self.virtual_builtins),
+                // Grow the native stack on demand so deep (non-tail) recursion doesn't overflow
+                // the OS thread stack — same idea as the bytecode VM's `stacker::maybe_grow` around
+                // recursive `run_chunk` (vm.rs:1138). Without it the tree-walker aborts (SIGABRT,
+                // "stack overflow") on deep recursion, which the cross-backend parity run surfaced
+                // on `recursion_stress`. This is the recursion ACCUMULATOR (every user-function call
+                // lands here); the per-element HOF path (`call_with_scope`) is deliberately NOT
+                // guarded — it never nests deeply, so it avoids the per-call check on hot map/filter.
+                //
+                // Red zone = 1 MiB, NOT the VM's 128 KiB: one tree-walker recursion level spans a
+                // long eval chain (eval_statement → eval_expr(if) → eval_expr(binary) → eval_expr(call)
+                // → eval_call_args → call_func → …), each frame large — far more per level than the
+                // VM's single `run_chunk` re-entry. 128 KiB is smaller than one level's chain, so the
+                // stack overflows BETWEEN checks; 1 MiB comfortably covers a level (verified to depth
+                // 20000 in both debug and release). 16 MiB segments keep grow frequency low.
+                let body_result = {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    {
+                        stacker::maybe_grow(1024 * 1024, 16 * 1024 * 1024, || {
+                            eval.eval_statement(body)
+                        })
+                    }
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                        eval.eval_statement(body)
+                    }
                 };
-                match eval.eval_statement(body) {
+                match body_result {
                     Ok(v) => Ok(v),
                     Err(EvalError::Return(v)) => Ok(v),
                     Err(EvalError::Throw(v)) => Err(EvalError::Throw(v)),
@@ -2828,7 +3209,6 @@ impl Evaluator {
         println!("Server listening on http://0.0.0.0:{}", port);
 
         if max_requests == Some(1) {
-            let port = port;
             std::thread::spawn(move || {
                 std::thread::sleep(std::time::Duration::from_millis(50));
                 if let Ok(mut stream) = std::net::TcpStream::connect(format!("127.0.0.1:{}", port))
@@ -2841,8 +3221,7 @@ impl Evaluator {
             });
         }
 
-        let mut count = 0usize;
-        for mut request in server.incoming_requests() {
+        for (count, mut request) in server.incoming_requests().enumerate() {
             let req_value = crate::http::request_to_value(&mut request);
 
             let response_value = match self.call_func(&handler, &[req_value]) {
@@ -2869,8 +3248,7 @@ impl Evaluator {
                 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) {
+            if max_requests.map(|m| count + 1 >= m).unwrap_or(false) {
                 break;
             }
         }
@@ -2887,8 +3265,11 @@ impl Evaluator {
                 }
                 tishlang_ast::CallArg::Spread(e) => {
                     let spread_val = self.eval_expr(e)?;
-                    if let Value::Array(arr) = spread_val {
+                    if let Value::Array(arr) = &spread_val {
                         result.extend(arr.borrow().iter().cloned());
+                    } else if let Some(items) = self.drain_eval_iterator(&spread_val) {
+                        // Spread a Map/Set iterator into call args (`f(...m.values())`).
+                        result.extend(items);
                     }
                 }
             }
@@ -3003,14 +3384,55 @@ impl Evaluator {
         }
     }
 
+    /// Drain a JS iterator object — one whose `next()` is a bridged core fn (`CoreFn`)
+    /// returning `{ value, done }`, e.g. a Map/Set iterator from `.values()` / `.keys()` /
+    /// `.entries()` — into a `Vec` by calling `next()` until `done`. Returns `None` when `v`
+    /// is not such an object. Shared by `for…of` and spread so both treat iterators like JS.
+    fn drain_eval_iterator(&self, v: &Value) -> Option<Vec<Value>> {
+        if !matches!(v, Value::Object(_)) {
+            return None;
+        }
+        // Fast path: tish's Map/Set iterators expose `__drain__`, returning all remaining items as
+        // one array — skips the per-element bridge + `{ value, done }` alloc of the generic loop.
+        if let Ok(Value::CoreFn(drain)) = self.get_prop(v, "__drain__") {
+            if let Value::Array(arr) = crate::value_convert::core_to_eval(drain.call(&[])) {
+                return Some(arr.borrow().clone());
+            }
+        }
+        let Ok(Value::CoreFn(next)) = self.get_prop(v, "next") else {
+            return None;
+        };
+        let mut out = Vec::new();
+        loop {
+            let res = crate::value_convert::core_to_eval(next.call(&[]));
+            let done = self
+                .get_prop(&res, "done")
+                .map(|x| x.is_truthy())
+                .unwrap_or(true);
+            if done {
+                break;
+            }
+            out.push(self.get_prop(&res, "value").unwrap_or(Value::Null));
+        }
+        Some(out)
+    }
+
     fn get_prop(&self, obj: &Value, key: &str) -> Result<Value, String> {
         match obj {
-            Value::Object(map) => Ok(map
-                .borrow()
-                .strings
-                .get(key)
-                .cloned()
-                .unwrap_or(Value::Null)),
+            Value::Object(map) => {
+                // `Set`/`Map` instances expose a computed `.size` via a hidden `SizeProbe` opaque
+                // (shared, not copied, across the value bridge — so it reflects the live store).
+                if key == "size" {
+                    if let Some(Value::Opaque(op)) =
+                        map.borrow().strings.get(tishlang_builtins::collections::SIZE_SLOT)
+                    {
+                        if let Some(n) = tishlang_builtins::collections::size_probe_len(op.as_ref()) {
+                            return Ok(Value::Number(n));
+                        }
+                    }
+                }
+                Ok(map.borrow().strings.get(key).cloned().unwrap_or(Value::Null))
+            }
             Value::Array(arr) => {
                 if key == "length" {
                     Ok(Value::Number(arr.borrow().len() as f64))
@@ -3051,6 +3473,9 @@ impl Evaluator {
                 "reject" => Ok(Value::Native(Self::promise_reject)),
                 "all" => Ok(Value::Native(Self::promise_all)),
                 "race" => Ok(Value::Native(Self::promise_race)),
+                "any" => Ok(Value::Native(Self::promise_any)),
+                "allSettled" => Ok(Value::Native(Self::promise_all_settled)),
+                "spawn" => Ok(Value::Native(Self::promise_spawn_interp)),
                 _ => Ok(Value::Null),
             },
             Value::Opaque(o) => {
@@ -3089,6 +3514,20 @@ impl Evaluator {
                 };
                 Ok(arr.borrow().get(idx).cloned().unwrap_or(Value::Null))
             }
+            // `str[i]` returns the character at index `i` (issue #17). The VM already does
+            // this; the interpreter previously fell through to `null`, a silent divergence.
+            // Out-of-bounds / negative / non-integer indices yield tish's nullish value.
+            Value::String(s) => {
+                let idx = match index {
+                    Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => *n as usize,
+                    _ => return Ok(Value::Null),
+                };
+                Ok(s
+                    .chars()
+                    .nth(idx)
+                    .map(|c| Value::String(c.to_string().into()))
+                    .unwrap_or(Value::Null))
+            }
             Value::Object(_) => Ok(eval_object_get(obj, index).unwrap_or(Value::Null)),
             #[cfg(feature = "http")]
             Value::Promise(_) | Value::CorePromise(_) => {
@@ -3316,30 +3755,21 @@ impl Evaluator {
                 format!("[{}]", inner.join(","))
             }
             Value::Object(map) => {
-                let mut entries: Vec<_> = map
+                // Insertion order (PropMap is an IndexMap) — matches JS/Node and the
+                // VM/rust backends. No key sort.
+                let entries: Vec<String> = map
                     .borrow()
                     .strings
                     .iter()
                     .map(|(k, v)| {
-                        (
-                            k.as_ref().to_string(),
-                            format!(
-                                "\"{}\":{}",
-                                k.replace('\\', "\\\\").replace('"', "\\\""),
-                                Self::json_stringify_value(v)
-                            ),
+                        format!(
+                            "\"{}\":{}",
+                            k.replace('\\', "\\\\").replace('"', "\\\""),
+                            Self::json_stringify_value(v)
                         )
                     })
                     .collect();
-                entries.sort_by(|a, b| a.0.cmp(&b.0));
-                format!(
-                    "{{{}}}",
-                    entries
-                        .into_iter()
-                        .map(|(_, s)| s)
-                        .collect::<Vec<_>>()
-                        .join(",")
-                )
+                format!("{{{}}}", entries.join(","))
             }
             Value::Symbol(_) => "null".to_string(),
             Value::Function { .. } | Value::Native(_) => "null".to_string(),
@@ -3597,6 +4027,124 @@ impl Evaluator {
         Err("Promise.race requires at least one promise".to_string())
     }
 
+    /// Helper: settle a new promise fulfilled with `v` (interp Value).
+    #[cfg(feature = "http")]
+    fn eval_fulfilled(v: Value) -> Result<Value, String> {
+        let (promise, resolve_val, reject_val) = crate::promise::create_promise();
+        let (resolve, _) = crate::promise::extract_resolvers(&resolve_val, &reject_val);
+        crate::promise::settle_promise(&resolve, v, true)?;
+        Ok(promise)
+    }
+
+    /// Helper: settle a new promise rejected with `v` (interp Value).
+    #[cfg(feature = "http")]
+    fn eval_rejected(v: Value) -> Result<Value, String> {
+        let (promise, resolve_val, reject_val) = crate::promise::create_promise();
+        let (_, reject) = crate::promise::extract_resolvers(&resolve_val, &reject_val);
+        crate::promise::settle_promise(&reject, v, false)?;
+        Ok(promise)
+    }
+
+    /// Await one interp promise/core-promise/value → `Result<Value, Value>`.
+    #[cfg(feature = "http")]
+    fn settle_one(v: Value) -> Result<Value, Value> {
+        match v {
+            Value::Promise(ref p) => match crate::promise::block_until_settled(p) {
+                crate::promise::PromiseAwaitResult::Fulfilled(x) => Ok(x),
+                crate::promise::PromiseAwaitResult::Rejected(x) => Err(x),
+                crate::promise::PromiseAwaitResult::Error(e) => {
+                    Err(Value::String(e.into()))
+                }
+            },
+            Value::CorePromise(ref p) => match p.block_until_settled() {
+                Ok(x) => Ok(crate::value_convert::core_to_eval(x)),
+                Err(x) => Err(crate::value_convert::core_to_eval(x)),
+            },
+            other => Ok(other),
+        }
+    }
+
+    /// `Promise.any(iterable)` — first fulfilled wins; rejects with array of reasons if all reject.
+    #[cfg(feature = "http")]
+    fn promise_any(args: &[Value]) -> Result<Value, String> {
+        let iterable = args
+            .first()
+            .ok_or_else(|| "Promise.any requires an iterable".to_string())?;
+        let values: Vec<Value> = match iterable {
+            Value::Array(arr) => arr.borrow().clone(),
+            _ => return Err("Promise.any requires an array".to_string()),
+        };
+        let n = values.len();
+        if n == 0 {
+            return Self::eval_rejected(Value::Array(Rc::new(RefCell::new(vec![]))));
+        }
+        let mut errors = Vec::with_capacity(n);
+        for v in values {
+            match Self::settle_one(v) {
+                Ok(x) => return Self::eval_fulfilled(x),
+                Err(e) => errors.push(e),
+            }
+        }
+        Self::eval_rejected(Value::Array(Rc::new(RefCell::new(errors))))
+    }
+
+    /// `Promise.allSettled(iterable)` — always fulfills with array of `{status,value|reason}`.
+    #[cfg(feature = "http")]
+    fn promise_all_settled(args: &[Value]) -> Result<Value, String> {
+        use crate::value::EvalObjectData;
+        let iterable = args
+            .first()
+            .ok_or_else(|| "Promise.allSettled requires an iterable".to_string())?;
+        let values: Vec<Value> = match iterable {
+            Value::Array(arr) => arr.borrow().clone(),
+            _ => return Err("Promise.allSettled requires an array".to_string()),
+        };
+        let mut out = Vec::with_capacity(values.len());
+        for v in values {
+            let r = Self::settle_one(v);
+            let mut data = EvalObjectData::default();
+            match r {
+                Ok(x) => {
+                    data.strings.insert(std::sync::Arc::from("status"), Value::String("fulfilled".into()));
+                    data.strings.insert(std::sync::Arc::from("value"), x);
+                }
+                Err(e) => {
+                    data.strings.insert(std::sync::Arc::from("status"), Value::String("rejected".into()));
+                    data.strings.insert(std::sync::Arc::from("reason"), e);
+                }
+            }
+            out.push(Value::Object(Rc::new(RefCell::new(data))));
+        }
+        Self::eval_fulfilled(Value::Array(Rc::new(RefCell::new(out))))
+    }
+
+    /// `Promise.spawn(fn)` — on the interpreter, runs the function synchronously and wraps
+    /// the result in an immediate promise. The interpreter uses `Rc<RefCell<…>>` for closures,
+    /// which is `!Send`, so we cannot move the function to a background thread here. Real
+    /// cross-thread parallelism via spawn is available on the bytecode VM (which uses the
+    /// `send-values` / Arc path for the shipped `full` build). For the interpreter, `any` and
+    /// `race` over spawn-created promises still work correctly — they just don't run concurrently.
+    #[cfg(feature = "http")]
+    fn promise_spawn_interp(args: &[Value]) -> Result<Value, String> {
+        let callable = match args.first() {
+            Some(v @ (Value::Native(_) | Value::Function { .. })) => v.clone(),
+            _ => return Err("Promise.spawn: expected a function argument".to_string()),
+        };
+        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+            match &callable {
+                Value::Native(f) => f(&[]).map_err(|e| e.to_string()),
+                // Interpreter closures (Value::Function) can't be called from a static native fn
+                // (no evaluator state / Rc captures). Use the VM backend for concurrent CPU spawn.
+                _ => Err("Promise.spawn: tish closures are not supported on the interpreter backend; use the vm backend (tish run) or pass a native module function".to_string()),
+            }
+        }));
+        match result {
+            Ok(Ok(v))  => Self::eval_fulfilled(v),
+            Ok(Err(e)) => Self::eval_rejected(Value::String(e.into())),
+            Err(_)     => Self::eval_rejected(Value::String("Promise.spawn: task panicked".into())),
+        }
+    }
+
     #[cfg(feature = "ws")]
     fn ws_web_socket_native(args: &[Value]) -> Result<Value, String> {
         let mut cv = Vec::new();