@tishlang/tish 1.6.0 → 1.8.0

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

@@ -3,15 +3,15 @@
 mod eval;
 #[cfg(feature = "http")]
 mod http;
-pub mod value_convert;
+mod natives;
 #[cfg(feature = "http")]
 mod promise;
-#[cfg(feature = "http")]
-mod timers;
-mod natives;
 #[cfg(feature = "regex")]
 pub mod regex;
+#[cfg(feature = "timers")]
+mod timers;
 mod value;
+pub mod value_convert;
 
 pub use eval::Evaluator;
 pub use value::PropMap;
@@ -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)
 }
@@ -51,16 +51,20 @@ pub fn format_value_for_console(value: &Value, colors: bool) -> String {
 }
 
 /// Run a Tish file with import/export support. Resolves relative imports from the file's directory.
-pub fn run_file(path: &std::path::Path, project_root: Option<&std::path::Path>) -> Result<Value, String> {
+pub fn run_file(
+    path: &std::path::Path,
+    project_root: Option<&std::path::Path>,
+) -> Result<Value, String> {
     let path = path
         .canonicalize()
         .map_err(|e| format!("Cannot canonicalize {}: {}", path.display(), e))?;
-    let source = std::fs::read_to_string(&path).map_err(|e| format!("Cannot read {}: {}", path.display(), e))?;
+    let source = std::fs::read_to_string(&path)
+        .map_err(|e| format!("Cannot read {}: {}", path.display(), e))?;
     let program = tishlang_parser::parse(&source)?;
     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

@@ -57,16 +57,21 @@ fn get_log_level() -> u8 {
 pub fn parse_int(args: &[Value]) -> Result<Value, String> {
     let s = args.first().map(|v| v.to_string()).unwrap_or_default();
     let s = s.trim();
-    let radix = args.get(1).and_then(|v| match v {
-        Value::Number(n) => Some(*n as i32),
-        _ => None,
-    }).unwrap_or(10);
+    let radix = args
+        .get(1)
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(10);
     let n = if (2..=36).contains(&radix) {
         let prefix: String = s
             .chars()
             .take_while(|c| *c == '-' || *c == '+' || c.is_digit(radix as u32))
             .collect();
-        i64::from_str_radix(&prefix, radix as u32).ok().map(|n| n as f64)
+        i64::from_str_radix(&prefix, radix as u32)
+            .ok()
+            .map(|n| n as f64)
     } else {
         None
     };
@@ -80,12 +85,16 @@ pub fn parse_float(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn is_finite(args: &[Value]) -> Result<Value, String> {
-    let b = args.first().is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite()));
+    let b = args
+        .first()
+        .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite()));
     Ok(Value::Bool(b))
 }
 
 pub fn is_nan(args: &[Value]) -> Result<Value, String> {
-    let b = args.first().is_none_or(|v| matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_)));
+    let b = args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    });
     Ok(Value::Bool(b))
 }
 
@@ -96,7 +105,9 @@ pub fn boolean_native(args: &[Value]) -> Result<Value, String> {
 
 pub fn decode_uri(args: &[Value]) -> Result<Value, String> {
     let s = args.first().map(|v| v.to_string()).unwrap_or_default();
-    Ok(Value::String(tishlang_core::percent_decode(&s).unwrap_or(s).into()))
+    Ok(Value::String(
+        tishlang_core::percent_decode(&s).unwrap_or(s).into(),
+    ))
 }
 
 pub fn encode_uri(args: &[Value]) -> Result<Value, String> {
@@ -104,42 +115,103 @@ 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()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).abs(),
+    ))
 }
 
 pub fn math_sqrt(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).sqrt()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).sqrt(),
+    ))
 }
 
 pub fn math_min(args: &[Value]) -> Result<Value, String> {
-    let nums: Vec<f64> = args.iter().filter_map(|v| match v {
-        Value::Number(n) => Some(*n),
-        _ => None,
-    }).collect();
+    let nums: Vec<f64> = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        })
+        .collect();
     let n = nums.into_iter().fold(f64::INFINITY, f64::min);
     Ok(Value::Number(if n == f64::INFINITY { f64::NAN } else { n }))
 }
 
 pub fn math_max(args: &[Value]) -> Result<Value, String> {
-    let nums: Vec<f64> = args.iter().filter_map(|v| match v {
-        Value::Number(n) => Some(*n),
-        _ => None,
-    }).collect();
+    let nums: Vec<f64> = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(*n),
+            _ => None,
+        })
+        .collect();
     let n = nums.into_iter().fold(f64::NEG_INFINITY, f64::max);
-    Ok(Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n }))
+    Ok(Value::Number(if n == f64::NEG_INFINITY {
+        f64::NAN
+    } else {
+        n
+    }))
 }
 
 pub fn math_floor(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).floor()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).floor(),
+    ))
 }
 
 pub fn math_ceil(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).ceil()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).ceil(),
+    ))
 }
 
 pub fn math_round(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).round()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).round(),
+    ))
 }
 
 pub fn math_random(_args: &[Value]) -> Result<Value, String> {
@@ -156,33 +228,53 @@ pub fn math_pow(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn math_sin(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).sin()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).sin(),
+    ))
 }
 
 pub fn math_cos(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).cos()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).cos(),
+    ))
 }
 
 pub fn math_tan(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).tan()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).tan(),
+    ))
 }
 
 pub fn math_log(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).ln()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).ln(),
+    ))
 }
 
 pub fn math_exp(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).exp()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).exp(),
+    ))
 }
 
 pub fn math_sign(args: &[Value]) -> Result<Value, String> {
     let n = get_num(args.first().unwrap_or(&Value::Null));
-    let sign = if n.is_nan() { f64::NAN } else if n > 0.0 { 1.0 } else if n < 0.0 { -1.0 } else { 0.0 };
+    let sign = if n.is_nan() {
+        f64::NAN
+    } else if n > 0.0 {
+        1.0
+    } else if n < 0.0 {
+        -1.0
+    } else {
+        0.0
+    };
     Ok(Value::Number(sign))
 }
 
 pub fn math_trunc(args: &[Value]) -> Result<Value, String> {
-    Ok(Value::Number(get_num(args.first().unwrap_or(&Value::Null)).trunc()))
+    Ok(Value::Number(
+        get_num(args.first().unwrap_or(&Value::Null)).trunc(),
+    ))
 }
 
 pub fn date_now(_args: &[Value]) -> Result<Value, String> {
@@ -199,19 +291,25 @@ pub fn array_is_array(args: &[Value]) -> Result<Value, String> {
 }
 
 pub fn string_from_char_code(args: &[Value]) -> Result<Value, String> {
-    let s: String = args.iter().filter_map(|v| match v {
-        Value::Number(n) => Some(char::from_u32(*n as u32).unwrap_or('\u{FFFD}')),
-        _ => None,
-    }).collect();
+    let s: String = args
+        .iter()
+        .filter_map(|v| match v {
+            Value::Number(n) => Some(char::from_u32(*n as u32).unwrap_or('\u{FFFD}')),
+            _ => None,
+        })
+        .collect();
     Ok(Value::String(s.into()))
 }
 
 #[cfg(feature = "process")]
 pub fn process_exit(args: &[Value]) -> Result<Value, String> {
-    let code = args.first().and_then(|v| match v {
-        Value::Number(n) => Some(*n as i32),
-        _ => None,
-    }).unwrap_or(0);
+    let code = args
+        .first()
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(0);
     std::process::exit(code);
 }
 
@@ -274,7 +372,7 @@ pub fn is_dir(args: &[Value]) -> Result<Value, String> {
 pub fn read_dir(args: &[Value]) -> Result<Value, String> {
     use std::cell::RefCell;
     use std::rc::Rc;
-    
+
     let path = args.first().map(|v| v.to_string()).unwrap_or_default();
     match std::fs::read_dir(&path) {
         Ok(entries) => {

package/crates/tish_eval/src/promise.rs

@@ -116,7 +116,11 @@ pub fn settle_promise(
         }
     };
     if let Some(tx) = tx {
-        let result = if is_resolve { Ok(value.clone()) } else { Err(value.clone()) };
+        let result = if is_resolve {
+            Ok(value.clone())
+        } else {
+            Err(value.clone())
+        };
         let _ = tx.send(result);
     }
     Ok((value, is_resolve, reactions))
@@ -134,7 +138,9 @@ pub fn add_reaction(state: &PromiseStateRef, reaction: Reaction) {
 impl Clone for Reaction {
     fn clone(&self) -> Self {
         match self {
-            Reaction::Then(a, b, r1, r2) => Reaction::Then(a.clone(), b.clone(), r1.clone(), r2.clone()),
+            Reaction::Then(a, b, r1, r2) => {
+                Reaction::Then(a.clone(), b.clone(), r1.clone(), r2.clone())
+            }
             Reaction::Finally(f, r1, r2) => Reaction::Finally(f.clone(), r1.clone(), r2.clone()),
         }
     }
@@ -156,18 +162,18 @@ pub fn block_until_settled(promise_ref: &PromiseRef) -> PromiseAwaitResult {
         match result {
             Ok(Ok(v)) => PromiseAwaitResult::Fulfilled(v),
             Ok(Err(v)) => PromiseAwaitResult::Rejected(v),
-            Err(_) => PromiseAwaitResult::Error(
-                "Promise channel dropped before settlement".to_string(),
-            ),
+            Err(_) => {
+                PromiseAwaitResult::Error("Promise channel dropped before settlement".to_string())
+            }
         }
     } else {
         let state = promise_ref.state.borrow();
         match &*state {
             PromiseState::Fulfilled(v) => PromiseAwaitResult::Fulfilled(v.clone()),
             PromiseState::Rejected(v) => PromiseAwaitResult::Rejected(v.clone()),
-            PromiseState::Pending { .. } => PromiseAwaitResult::Error(
-                "Promise receiver already consumed".to_string(),
-            ),
+            PromiseState::Pending { .. } => {
+                PromiseAwaitResult::Error("Promise receiver already consumed".to_string())
+            }
         }
     }
 }

package/crates/tish_eval/src/timers.rs

@@ -4,8 +4,8 @@
 
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::time::{Duration, Instant};
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{Duration, Instant};
 
 use crate::value::Value;
 
@@ -32,12 +32,15 @@ pub fn setTimeout(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
     let id = next_id();
     let due = Instant::now() + Duration::from_millis(delay_ms);
     REGISTRY.with(|r| {
-        r.borrow_mut().insert(id, TimerEntry {
-            due,
-            callback,
-            args,
-            interval_ms: 0,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms: 0,
+            },
+        );
     });
     id
 }
@@ -48,12 +51,15 @@ pub fn setInterval(callback: Value, args: Vec<Value>, delay_ms: u64) -> u64 {
     let id = next_id();
     let due = Instant::now() + Duration::from_millis(delay_ms);
     REGISTRY.with(|r| {
-        r.borrow_mut().insert(id, TimerEntry {
-            due,
-            callback,
-            args,
-            interval_ms: delay_ms,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms: delay_ms,
+            },
+        );
     });
     id
 }
@@ -88,12 +94,15 @@ pub fn take_due_timers() -> Vec<(u64, Value, Vec<Value>, u64)> {
 pub fn re_register_interval(id: u64, callback: Value, args: Vec<Value>, interval_ms: u64) {
     let due = Instant::now() + Duration::from_millis(interval_ms);
     REGISTRY.with(|r| {
-        r.borrow_mut().insert(id, TimerEntry {
-            due,
-            callback,
-            args,
-            interval_ms,
-        });
+        r.borrow_mut().insert(
+            id,
+            TimerEntry {
+                due,
+                callback,
+                args,
+                interval_ms,
+            },
+        );
     });
 }
 

package/crates/tish_eval/src/value.rs

@@ -15,9 +15,9 @@ use tishlang_core::NativeFn as CoreNativeFn;
 
 /// Property map for interpreter `Value::Object` (uses `eval::Value`, not `tishlang_core::Value`).
 pub type PropMap = AHashMap<Arc<str>, Value>;
+use tishlang_core::TishOpaque;
 #[cfg(feature = "http")]
 use tishlang_core::TishPromise;
-use tishlang_core::TishOpaque;
 
 #[cfg(feature = "http")]
 pub use crate::promise::PromiseResolver;
@@ -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")]
@@ -88,7 +88,12 @@ impl std::fmt::Debug for Value {
             #[cfg(feature = "http")]
             Value::Serve => write!(f, "Serve"),
             #[cfg(feature = "regex")]
-            Value::RegExp(re) => write!(f, "RegExp(/{}/{})", re.borrow().source, re.borrow().flags_string()),
+            Value::RegExp(re) => write!(
+                f,
+                "RegExp(/{}/{})",
+                re.borrow().source,
+                re.borrow().flags_string()
+            ),
             #[cfg(feature = "http")]
             Value::Promise(_) => write!(f, "Promise"),
             #[cfg(feature = "http")]
@@ -96,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"),
@@ -151,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]"),
@@ -187,7 +196,9 @@ impl Value {
             (Value::Array(a), Value::Array(b)) => Rc::ptr_eq(a, b),
             (Value::Object(a), Value::Object(b)) => Rc::ptr_eq(a, b),
             (Value::Opaque(a), Value::Opaque(b)) => Arc::ptr_eq(a, b),
-            (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => Arc::ptr_eq(a, b) && ak == bk,
+            (Value::OpaqueMethod(a, ak), Value::OpaqueMethod(b, bk)) => {
+                Arc::ptr_eq(a, b) && ak == bk
+            }
             _ => false,
         }
     }

package/crates/tish_eval/src/value_convert.rs

@@ -4,7 +4,9 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_core::{ObjectMap, Value as CoreValue};
+use tishlang_core::{ObjectMap, Value as CoreValue, VmRef};
+#[cfg(feature = "regex")]
+use tishlang_core::TishRegExp;
 
 use crate::value::{PropMap, Value};
 
@@ -20,14 +22,14 @@ pub fn eval_to_core(v: &Value) -> Result<CoreValue, String> {
             for item in arr.borrow().iter() {
                 out.push(eval_to_core(item)?);
             }
-            Ok(CoreValue::Array(Rc::new(RefCell::new(out))))
+            Ok(CoreValue::Array(VmRef::new(out)))
         }
         Value::Object(map) => {
             let mut out = ObjectMap::default();
             for (k, v) in map.borrow().iter() {
                 out.insert(Arc::clone(k), eval_to_core(v)?);
             }
-            Ok(CoreValue::Object(Rc::new(RefCell::new(out))))
+            Ok(CoreValue::Object(VmRef::new(out)))
         }
         Value::Opaque(o) => Ok(CoreValue::Opaque(Arc::clone(o))),
         _ => Err(format!(
@@ -63,13 +65,19 @@ pub fn core_to_eval(v: CoreValue) -> Value {
         CoreValue::Promise(p) => Value::CorePromise(Arc::clone(&p)),
         #[cfg(not(feature = "http"))]
         CoreValue::Promise(_) => Value::Null,
-        CoreValue::Function(f) => Value::CoreFn(Rc::clone(&f)),
+        // `CoreNativeFn` is feature-gated (Rc vs Arc), so use Clone::clone
+        // which works for either.
+        CoreValue::Function(f) => Value::CoreFn(f.clone()),
         // tishlang_core gets regex from http or regex features; handle RegExp when it exists
         #[cfg(any(feature = "http", feature = "regex"))]
         CoreValue::RegExp(re) => {
             #[cfg(feature = "regex")]
             {
-                Value::RegExp(re)
+                // Core uses `VmRef<TishRegExp>` (potentially `Arc<Mutex>`),
+                // interpreter uses `Rc<RefCell<TishRegExp>>`. Clone the
+                // inner state across so the two storage shapes can coexist.
+                let inner: TishRegExp = re.borrow().clone();
+                Value::RegExp(Rc::new(RefCell::new(inner)))
             }
             #[cfg(not(feature = "regex"))]
             {