@tishlang/tish 1.0.29 → 1.0.34

package/crates/tish_eval/src/eval.rs

@@ -8,14 +8,14 @@ use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_ast::{BinOp, CompoundOp, ExportDeclaration, Expr, ImportSpecifier, Literal, LogicalAssignOp, MemberProp, Span, Statement, UnaryOp};
+use tishlang_ast::{BinOp, CompoundOp, ExportDeclaration, Expr, FunParam, ImportSpecifier, Literal, LogicalAssignOp, MemberProp, Span, Statement, UnaryOp};
 
-use crate::value::Value;
+use crate::value::{PropMap, Value};
 #[cfg(any(feature = "fs", feature = "process"))]
 use crate::natives;
 
 struct Scope {
-    vars: HashMap<Arc<str>, Value>,
+    vars: PropMap,
     consts: std::collections::HashSet<Arc<str>>,
     parent: Option<Rc<std::cell::RefCell<Scope>>>,
 }
@@ -23,7 +23,7 @@ struct Scope {
 impl Scope {
     fn new() -> Rc<std::cell::RefCell<Self>> {
         Rc::new(std::cell::RefCell::new(Self {
-            vars: HashMap::new(),
+            vars: PropMap::default(),
             consts: std::collections::HashSet::new(),
             parent: None,
         }))
@@ -31,7 +31,7 @@ impl Scope {
 
     fn child(parent: Rc<std::cell::RefCell<Scope>>) -> Rc<std::cell::RefCell<Self>> {
         Rc::new(std::cell::RefCell::new(Self {
-            vars: HashMap::new(),
+            vars: PropMap::default(),
             consts: std::collections::HashSet::new(),
             parent: Some(parent),
         }))
@@ -75,6 +75,8 @@ pub struct Evaluator {
     module_cache: Rc<RefCell<HashMap<PathBuf, Value>>>,
     /// Directory of the file currently being evaluated (for resolving relative imports)
     current_dir: RefCell<Option<PathBuf>>,
+    /// Extra `tish:*` builtins from `TishNativeModule::virtual_builtin_modules` (shared across nested evaluators).
+    virtual_builtins: Rc<RefCell<HashMap<Arc<str>, Value>>>,
 }
 
 impl Evaluator {
@@ -85,7 +87,7 @@ impl Evaluator {
         let scope = Scope::new();
         {
             let mut s = scope.borrow_mut();
-            let mut console = HashMap::with_capacity(5);
+            let mut console = PropMap::with_capacity(5);
             console.insert("debug".into(), Value::Native(natives::console_debug));
             console.insert("info".into(), Value::Native(natives::console_info));
             console.insert("log".into(), Value::Native(natives::console_log));
@@ -101,7 +103,7 @@ impl Evaluator {
             s.set("isNaN".into(), Value::Native(natives::is_nan), true);
             s.set("Infinity".into(), Value::Number(f64::INFINITY), true);
             s.set("NaN".into(), Value::Number(f64::NAN), true);
-            let mut math = HashMap::with_capacity(18);
+            let mut math = PropMap::with_capacity(18);
             math.insert("abs".into(), Value::Native(natives::math_abs));
             math.insert("sqrt".into(), Value::Native(natives::math_sqrt));
             math.insert("min".into(), Value::Native(natives::math_min));
@@ -122,12 +124,12 @@ impl Evaluator {
             math.insert("E".into(), Value::Number(std::f64::consts::E));
             s.set("Math".into(), Value::Object(Rc::new(RefCell::new(math))), true);
 
-            let mut json = HashMap::with_capacity(2);
+            let mut json = PropMap::with_capacity(2);
             json.insert("parse".into(), Value::Native(Self::json_parse_native));
             json.insert("stringify".into(), Value::Native(Self::json_stringify_native));
             s.set("JSON".into(), Value::Object(Rc::new(RefCell::new(json))), true);
 
-            let mut object = HashMap::with_capacity(5);
+            let mut object = PropMap::with_capacity(5);
             object.insert("keys".into(), Value::Native(Self::object_keys));
             object.insert("values".into(), Value::Native(Self::object_values));
             object.insert("entries".into(), Value::Native(Self::object_entries));
@@ -135,18 +137,33 @@ impl Evaluator {
             object.insert("fromEntries".into(), Value::Native(Self::object_from_entries));
             s.set("Object".into(), Value::Object(Rc::new(RefCell::new(object))), true);
 
-            let mut array_obj = HashMap::with_capacity(1);
+            let mut array_obj = PropMap::with_capacity(1);
             array_obj.insert("isArray".into(), Value::Native(natives::array_is_array));
             s.set("Array".into(), Value::Object(Rc::new(RefCell::new(array_obj))), true);
 
-            let mut string_obj = HashMap::with_capacity(1);
+            let mut string_obj = PropMap::with_capacity(1);
             string_obj.insert("fromCharCode".into(), Value::Native(natives::string_from_char_code));
             s.set("String".into(), Value::Object(Rc::new(RefCell::new(string_obj))), true);
 
-            let mut date = HashMap::with_capacity(1);
+            let mut date = PropMap::with_capacity(1);
             date.insert("now".into(), Value::Native(natives::date_now));
             s.set("Date".into(), Value::Object(Rc::new(RefCell::new(date))), true);
 
+            s.set(
+                "Uint8Array".into(),
+                crate::value_convert::core_to_eval(
+                    tishlang_builtins::construct::uint8_array_constructor_value(),
+                ),
+                true,
+            );
+            s.set(
+                "AudioContext".into(),
+                crate::value_convert::core_to_eval(
+                    tishlang_builtins::construct::audio_context_constructor_value(),
+                ),
+                true,
+            );
+
             #[cfg(feature = "regex")]
             {
                 s.set("RegExp".into(), Value::Native(Self::regexp_constructor_native), true);
@@ -158,6 +175,7 @@ impl Evaluator {
             scope,
             module_cache: Rc::new(RefCell::new(HashMap::new())),
             current_dir: RefCell::new(None),
+            virtual_builtins: Rc::new(RefCell::new(HashMap::new())),
         }
     }
 
@@ -172,6 +190,14 @@ impl Evaluator {
                 }
             }
         }
+        {
+            let mut vb = eval.virtual_builtins.borrow_mut();
+            for module in modules {
+                for (spec, value) in module.virtual_builtin_modules() {
+                    vb.insert(Arc::from(spec), value);
+                }
+            }
+        }
         eval
     }
 
@@ -323,14 +349,11 @@ impl Evaluator {
                 body,
                 ..
             } => {
-                // Extract parameter names and defaults using Arc for cheap cloning
-                let param_names: Arc<[Arc<str>]> = params.iter().map(|p| Arc::clone(&p.name)).collect();
-                let defaults: Arc<[Option<Expr>]> = params.iter().map(|p| p.default.clone()).collect();
+                let formals: Arc<[FunParam]> = Arc::from(params.clone());
                 let rest_param_name = rest_param.as_ref().map(|p| Arc::clone(&p.name));
                 let body = Arc::new(body.as_ref().clone());
                 let func = Value::Function {
-                    params: param_names,
-                    defaults,
+                    formals,
                     rest_param: rest_param_name,
                     body,
                 };
@@ -490,7 +513,7 @@ impl Evaluator {
     /// Load and evaluate a module, returning its exports object. Uses cache.
     fn load_module(&mut self, from: &str) -> Result<Value, EvalError> {
         if from.starts_with("tish:") {
-            return Self::load_builtin_module(from);
+            return self.load_builtin_module(from);
         }
         let dir = self.current_dir.borrow().clone().ok_or_else(|| {
             EvalError::Error("Cannot resolve imports: no current file directory (use run_file)".to_string())
@@ -536,7 +559,7 @@ impl Evaluator {
                 let _ = self.eval_statement(stmt);
             }
         }
-        let mut exports: HashMap<Arc<str>, Value> = HashMap::new();
+        let mut exports: PropMap = PropMap::default();
         for name in export_names {
             if let Some(v) = module_scope.borrow().get(&name) {
                 exports.insert(Arc::from(name.as_str()), v);
@@ -570,13 +593,16 @@ impl Evaluator {
         Ok(path)
     }
 
-    /// Load built-in module (tish:fs, tish:http, tish:process). Features auto-enabled when imported.
-    fn load_builtin_module(spec: &str) -> Result<Value, EvalError> {
+    /// Load built-in module (tish:fs, tish:http, tish:process, …) or a virtual module from native crates.
+    fn load_builtin_module(&self, spec: &str) -> Result<Value, EvalError> {
+        if let Some(v) = self.virtual_builtins.borrow().get(spec) {
+            return Ok(v.clone());
+        }
         match spec {
             "tish:fs" => {
                 #[cfg(feature = "fs")]
                 {
-                    let mut exports: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut exports: PropMap = PropMap::default();
                     exports.insert("readFile".into(), Value::Native(natives::read_file));
                     exports.insert("writeFile".into(), Value::Native(natives::write_file));
                     exports.insert("fileExists".into(), Value::Native(natives::file_exists));
@@ -595,7 +621,7 @@ impl Evaluator {
             "tish:http" => {
                 #[cfg(feature = "http")]
                 {
-                    let mut exports: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut exports: PropMap = PropMap::default();
                     exports.insert("fetch".into(), Value::Native(Self::fetch_native));
                     exports.insert("fetchAll".into(), Value::Native(Self::fetch_all_native));
                     exports.insert("serve".into(), Value::Serve);
@@ -616,7 +642,7 @@ impl Evaluator {
             "tish:ws" => {
                 #[cfg(feature = "ws")]
                 {
-                    let mut exports: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut exports: PropMap = PropMap::default();
                     exports.insert("WebSocket".into(), Value::Native(Self::ws_web_socket_native));
                     exports.insert("Server".into(), Value::Native(Self::ws_server_native));
                     exports.insert("wsSend".into(), Value::Native(Self::ws_send_native));
@@ -633,7 +659,7 @@ impl Evaluator {
             "tish:process" => {
                 #[cfg(feature = "process")]
                 {
-                    let mut exports: HashMap<Arc<str>, Value> = HashMap::new();
+                    let mut exports: PropMap = PropMap::default();
                     exports.insert("exit".into(), Value::Native(natives::process_exit));
                     exports.insert("cwd".into(), Value::Native(natives::process_cwd));
                     exports.insert("exec".into(), Value::Native(natives::process_exec));
@@ -641,11 +667,11 @@ impl Evaluator {
                         .map(|s| Value::String(s.into()))
                         .collect();
                     exports.insert("argv".into(), Value::Array(Rc::new(RefCell::new(argv.clone()))));
-                    let env_obj: HashMap<Arc<str>, Value> = std::env::vars()
+                    let env_obj: PropMap = std::env::vars()
                         .map(|(key, value)| (Arc::from(key.as_str()), Value::String(value.into())))
                         .collect();
                     exports.insert("env".into(), Value::Object(Rc::new(RefCell::new(env_obj.clone()))));
-                    let mut process_obj = HashMap::new();
+                    let mut process_obj = PropMap::default();
                     process_obj.insert("exit".into(), Value::Native(natives::process_exit));
                     process_obj.insert("cwd".into(), Value::Native(natives::process_cwd));
                     process_obj.insert("exec".into(), Value::Native(natives::process_exec));
@@ -663,15 +689,15 @@ impl Evaluator {
             }
             _ => {
                 return Err(EvalError::Error(format!(
-                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:process, tish:ws",
+                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:process, tish:ws (plus any registered by native modules)",
                     spec
                 )));
             }
         }
     }
 
-    fn load_builtin_export(spec: &str, export_name: &str) -> Result<Value, EvalError> {
-        let module = Self::load_builtin_module(spec)?;
+    fn load_builtin_export(&self, spec: &str, export_name: &str) -> Result<Value, EvalError> {
+        let module = self.load_builtin_module(spec)?;
         let exports = match &module {
             Value::Object(m) => m.borrow().clone(),
             _ => return Err(EvalError::Error("Built-in module must be object".into())),
@@ -1534,7 +1560,7 @@ impl Evaluator {
                 Ok(Value::Array(Rc::new(RefCell::new(vals))))
             }
             Expr::Object { props, .. } => {
-                let mut map = HashMap::new();
+                let mut map = PropMap::default();
                 for prop in props {
                     match prop {
                         tishlang_ast::ObjectProp::KeyValue(k, v) => {
@@ -1561,11 +1587,16 @@ impl Evaluator {
                 }
             }
             Expr::Await { operand, .. } => self.eval_await(operand),
+            Expr::New { callee, args, .. } => {
+                let c = self.eval_expr(callee)?;
+                let arg_vals = self.eval_call_args(args)?;
+                self.construct_value(&c, &arg_vals)
+            }
             Expr::JsxElement { .. } | Expr::JsxFragment { .. } => Err(EvalError::Error(
                 "JSX is not supported in the interpreter. Use 'tish compile --target js' to compile to JavaScript.".to_string(),
             )),
             Expr::NativeModuleLoad { spec, export_name, .. } => {
-                Self::load_builtin_export(spec.as_ref(), export_name.as_ref())
+                self.load_builtin_export(spec.as_ref(), export_name.as_ref())
             }
             Expr::TypeOf { operand, .. } => {
                 let v = self.eval_expr(operand)?;
@@ -1577,7 +1608,6 @@ impl Evaluator {
                     Value::Array(_) => "object".into(),
                     Value::Object(_) => "object".into(),
                     Value::Function { .. } | Value::Native(_) => "function".into(),
-                    #[cfg(any(feature = "http", feature = "ws"))]
                     Value::CoreFn(_) => "function".into(),
                     #[cfg(feature = "http")]
                     Value::CorePromise(_) => "object".into(),
@@ -1755,9 +1785,7 @@ impl Evaluator {
             }
             Expr::ArrowFunction { params, body, .. } => {
                 use tishlang_ast::ArrowBody;
-                // Convert arrow function to regular function using Arc for cheap cloning
-                let param_names: Arc<[Arc<str>]> = params.iter().map(|p| Arc::clone(&p.name)).collect();
-                let defaults: Arc<[Option<tishlang_ast::Expr>]> = params.iter().map(|p| p.default.clone()).collect();
+                let formals: Arc<[FunParam]> = Arc::from(params.clone());
                 let body_stmt = match body {
                     ArrowBody::Expr(expr) => {
                         // Expression body: wrap in implicit return
@@ -1769,8 +1797,7 @@ impl Evaluator {
                     ArrowBody::Block(stmt) => stmt.as_ref().clone(),
                 };
                 Ok(Value::Function {
-                    params: param_names,
-                    defaults,
+                    formals,
                     rest_param: None,
                     body: Arc::new(body_stmt),
                 })
@@ -1862,18 +1889,21 @@ impl Evaluator {
     /// descending = false: checks for `(a, b) => a - b`
     /// descending = true: checks for `(a, b) => b - a`
     fn is_numeric_sort_comparator(f: &Value, descending: bool) -> bool {
-        if let Value::Function { params, body, defaults, rest_param } = f {
-            // Must have exactly 2 params, no defaults, no rest
-            if params.len() != 2 || rest_param.is_some() {
-                return false;
-            }
-            if defaults.iter().any(|d| d.is_some()) {
+        if let Value::Function { formals, body, rest_param, .. } = f {
+            // Must have exactly 2 simple params, no defaults, no rest
+            if formals.len() != 2 || rest_param.is_some() {
                 return false;
             }
+            let (param_a, param_b) = match (&formals[0], &formals[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (&a.name, &b.name)
+                }
+                _ => return false,
+            };
 
             // Body must be a return of a - b (or b - a for descending)
-            let param_a = &params[0];
-            let param_b = &params[1];
 
             // Check for both Statement::Return and Statement::ExprStmt (arrow implicit return)
             let expr = match body.as_ref() {
@@ -1947,20 +1977,32 @@ impl Evaluator {
     /// Optimized callback invocation for array methods.
     /// Creates a reusable scope that can be updated for each iteration.
     fn create_callback_scope(&self, f: &Value) -> Option<(Rc<RefCell<Scope>>, Arc<[Arc<str>]>, Arc<Statement>)> {
-        if let Value::Function { params, body, defaults, rest_param } = f {
-            // Only optimize simple cases: no defaults used, no rest params
-            if rest_param.is_some() || defaults.iter().any(|d| d.is_some()) {
+        if let Value::Function { formals, body, rest_param, .. } = f {
+            if rest_param.is_some() {
                 return None;
             }
+            for fp in formals.iter() {
+                match fp {
+                    FunParam::Simple(tp) if tp.default.is_none() => {}
+                    _ => return None,
+                }
+            }
             let scope = Scope::child(Rc::clone(&self.scope));
-            // Pre-initialize parameters to Null
             {
                 let mut s = scope.borrow_mut();
-                for p in params.iter() {
-                    s.set(Arc::clone(p), Value::Null, true);
+                for fp in formals.iter() {
+                    for n in fp.bound_names() {
+                        s.set(n, Value::Null, true);
+                    }
                 }
             }
-            return Some((scope, Arc::clone(params), Arc::clone(body)));
+            let flat_names: Arc<[Arc<str>]> = Arc::from(
+                formals
+                    .iter()
+                    .flat_map(|fp| fp.bound_names())
+                    .collect::<Vec<_>>(),
+            );
+            return Some((scope, flat_names, Arc::clone(body)));
         }
         None
     }
@@ -1987,6 +2029,7 @@ impl 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),
         };
         match eval.eval_statement(body) {
             Ok(v) => Ok(v),
@@ -2002,12 +2045,14 @@ impl Evaluator {
         f: &Value,
         args: &[Value],
     ) -> Option<Result<Value, EvalError>> {
-        if let Value::Function { params, body, defaults, rest_param } = f {
-            // Only optimize single-parameter functions without defaults or rest
-            if params.len() != 1 || rest_param.is_some() || defaults.iter().any(|d| d.is_some()) {
+        if let Value::Function { formals, body, rest_param, .. } = f {
+            if formals.len() != 1 || rest_param.is_some() {
                 return None;
             }
-            let param_name = &params[0];
+            let param_name = match &formals[0] {
+                FunParam::Simple(tp) if tp.default.is_none() => &tp.name,
+                _ => return None,
+            };
             let arg = args.first().cloned().unwrap_or(Value::Null);
 
             // Get the expression from the body
@@ -2078,6 +2123,27 @@ impl Evaluator {
         }
     }
 
+    /// Host `new`: `__construct` on objects; otherwise same callables as `call_func`, else null.
+    fn construct_value(&self, callee: &Value, args: &[Value]) -> Result<Value, EvalError> {
+        if let Value::Object(o) = callee {
+            if let Some(ctor) = o.borrow().get(&Arc::from("__construct")) {
+                return self.call_func(ctor, args);
+            }
+        }
+        match callee {
+            Value::Native(_) | Value::Function { .. } | Value::CoreFn(_) => {
+                self.call_func(callee, args)
+            }
+            #[cfg(feature = "http")]
+            Value::PromiseConstructor
+            | Value::Serve
+            | Value::BoundPromiseMethod(_, _)
+            | Value::TimerBuiltin(_) => self.call_func(callee, args),
+            Value::OpaqueMethod(_, _) => self.call_func(callee, args),
+            _ => Ok(Value::Null),
+        }
+    }
+
     fn call_func(&self, f: &Value, args: &[Value]) -> Result<Value, EvalError> {
         match f {
             Value::Native(native_fn) => {
@@ -2142,7 +2208,6 @@ impl Evaluator {
             }
             #[cfg(feature = "http")]
             Value::Serve => self.run_http_server(args),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(f) => {
                 let ca: Result<Vec<tishlang_core::Value>, String> =
                     args.iter().map(crate::value_convert::eval_to_core).collect();
@@ -2167,15 +2232,19 @@ impl Evaluator {
                 let result = method(&core_args);
                 Ok(crate::value_convert::core_to_eval(result))
             }
-            Value::Function { params, defaults, rest_param, body } => {
+            Value::Function { formals, rest_param, body } => {
                 let scope = Scope::child(Rc::clone(&self.scope));
                 {
                     let mut s = scope.borrow_mut();
-                    for (i, p) in params.iter().enumerate() {
+                    for (i, formal) in formals.iter().enumerate() {
                         let val = match args.get(i) {
                             Some(v) => v.clone(),
                             None => {
-                                if let Some(Some(default_expr)) = defaults.get(i) {
+                                let def = match formal {
+                                    FunParam::Simple(tp) => tp.default.as_ref(),
+                                    FunParam::Destructure { default, .. } => default.as_ref(),
+                                };
+                                if let Some(default_expr) = def {
                                     drop(s);
                                     let default_val = self.eval_expr(default_expr)?;
                                     s = scope.borrow_mut();
@@ -2185,10 +2254,19 @@ impl Evaluator {
                                 }
                             }
                         };
-                        s.set(Arc::clone(p), val, true);
+                        match formal {
+                            FunParam::Simple(tp) => {
+                                s.set(Arc::clone(&tp.name), val, true);
+                            }
+                            FunParam::Destructure { pattern, .. } => {
+                                drop(s);
+                                Self::bind_destruct_pattern_scoped(&scope, pattern, &val, true)?;
+                                s = scope.borrow_mut();
+                            }
+                        }
                     }
                     if let Some(ref rest_name) = rest_param {
-                        let rest_vals: Vec<Value> = args.iter().skip(params.len()).cloned().collect();
+                        let rest_vals: Vec<Value> = args.iter().skip(formals.len()).cloned().collect();
                         s.set(Arc::clone(rest_name), Value::Array(Rc::new(RefCell::new(rest_vals))), true);
                     }
                 }
@@ -2196,6 +2274,7 @@ impl 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),
                 };
                 match eval.eval_statement(body) {
                     Ok(v) => Ok(v),
@@ -2449,13 +2528,13 @@ impl Evaluator {
             let response_value = match self.call_func(&handler, &[req_value]) {
                 Ok(v) => v,
                 Err(EvalError::Throw(v)) => {
-                    let mut err_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+                    let mut err_obj: PropMap = PropMap::with_capacity(2);
                     err_obj.insert(Arc::from("status"), Value::Number(500.0));
                     err_obj.insert(Arc::from("body"), Value::String(v.to_string().into()));
                     Value::Object(Rc::new(RefCell::new(err_obj)))
                 }
                 Err(e) => {
-                    let mut err_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(2);
+                    let mut err_obj: PropMap = PropMap::with_capacity(2);
                     err_obj.insert(Arc::from("status"), Value::Number(500.0));
                     err_obj.insert(Arc::from("body"), Value::String(e.to_string().into()));
                     Value::Object(Rc::new(RefCell::new(err_obj)))
@@ -2491,28 +2570,37 @@ impl Evaluator {
         Ok(result)
     }
 
-    fn bind_destruct_pattern(&mut self, pattern: &tishlang_ast::DestructPattern, value: &Value, mutable: bool) -> Result<(), EvalError> {
+    fn bind_destruct_pattern_scoped(
+        scope: &Rc<RefCell<Scope>>,
+        pattern: &tishlang_ast::DestructPattern,
+        value: &Value,
+        mutable: bool,
+    ) -> Result<(), EvalError> {
         match pattern {
             tishlang_ast::DestructPattern::Array(elements) => {
                 let arr = match value {
                     Value::Array(a) => a.borrow().clone(),
                     _ => return Err(EvalError::Error("Cannot destructure non-array value".to_string())),
                 };
-                
+
                 for (i, elem) in elements.iter().enumerate() {
                     if let Some(el) = elem {
                         match el {
                             tishlang_ast::DestructElement::Ident(name) => {
                                 let val = arr.get(i).cloned().unwrap_or(Value::Null);
-                                self.scope.borrow_mut().set(Arc::clone(name), val, mutable);
+                                scope.borrow_mut().set(Arc::clone(name), val, mutable);
                             }
                             tishlang_ast::DestructElement::Pattern(nested) => {
                                 let val = arr.get(i).cloned().unwrap_or(Value::Null);
-                                self.bind_destruct_pattern(nested, &val, mutable)?;
+                                Self::bind_destruct_pattern_scoped(scope, nested, &val, mutable)?;
                             }
                             tishlang_ast::DestructElement::Rest(name) => {
                                 let rest: Vec<Value> = arr.iter().skip(i).cloned().collect();
-                                self.scope.borrow_mut().set(Arc::clone(name), Value::Array(Rc::new(RefCell::new(rest))), mutable);
+                                scope.borrow_mut().set(
+                                    Arc::clone(name),
+                                    Value::Array(Rc::new(RefCell::new(rest))),
+                                    mutable,
+                                );
                                 break;
                             }
                         }
@@ -2524,18 +2612,20 @@ impl Evaluator {
                     Value::Object(o) => o.borrow().clone(),
                     _ => return Err(EvalError::Error("Cannot destructure non-object value".to_string())),
                 };
-                
+
                 for prop in props {
                     let val = obj.get(&prop.key).cloned().unwrap_or(Value::Null);
                     match &prop.value {
                         tishlang_ast::DestructElement::Ident(name) => {
-                            self.scope.borrow_mut().set(Arc::clone(name), val, mutable);
+                            scope.borrow_mut().set(Arc::clone(name), val, mutable);
                         }
                         tishlang_ast::DestructElement::Pattern(nested) => {
-                            self.bind_destruct_pattern(nested, &val, mutable)?;
+                            Self::bind_destruct_pattern_scoped(scope, nested, &val, mutable)?;
                         }
                         tishlang_ast::DestructElement::Rest(_) => {
-                            return Err(EvalError::Error("Rest not supported in object destructuring".to_string()));
+                            return Err(EvalError::Error(
+                                "Rest not supported in object destructuring".to_string(),
+                            ));
                         }
                     }
                 }
@@ -2544,6 +2634,10 @@ impl Evaluator {
         Ok(())
     }
 
+    fn bind_destruct_pattern(&mut self, pattern: &tishlang_ast::DestructPattern, value: &Value, mutable: bool) -> Result<(), EvalError> {
+        Self::bind_destruct_pattern_scoped(&self.scope, pattern, value, mutable)
+    }
+
     fn get_prop(&self, obj: &Value, key: &str) -> Result<Value, String> {
         match obj {
             Value::Object(map) => Ok(map.borrow().get(key).cloned().unwrap_or(Value::Null)),
@@ -2745,9 +2839,9 @@ impl Evaluator {
     fn json_parse_object(s: &str) -> Result<Value, ()> {
         let s = s[1..].trim_start();
         if s.starts_with('}') {
-            return Ok(Value::Object(Rc::new(RefCell::new(HashMap::new()))));
+            return Ok(Value::Object(Rc::new(RefCell::new(PropMap::default()))));
         }
-        let mut map = HashMap::new();
+        let mut map = PropMap::default();
         let mut rest = s;
         loop {
             if !rest.starts_with('"') {
@@ -2873,7 +2967,6 @@ impl Evaluator {
             Value::Function { .. } | Value::Native(_) => "null".to_string(),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => "null".to_string(),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(_) => "null".to_string(),
             #[cfg(feature = "http")]
             Value::Serve
@@ -2949,7 +3042,7 @@ impl Evaluator {
 
     fn object_from_entries(args: &[Value]) -> Result<Value, String> {
         if let Some(Value::Array(arr)) = args.first() {
-            let mut map = HashMap::new();
+            let mut map = PropMap::default();
             for entry in arr.borrow().iter() {
                 if let Value::Array(pair) = entry {
                     let pair = pair.borrow();
@@ -2961,7 +3054,7 @@ impl Evaluator {
             }
             Ok(Value::Object(Rc::new(RefCell::new(map))))
         } else {
-            Ok(Value::Object(Rc::new(RefCell::new(HashMap::new()))))
+            Ok(Value::Object(Rc::new(RefCell::new(PropMap::default()))))
         }
     }
 

package/crates/tish_eval/src/http.rs

@@ -1,7 +1,6 @@
 //! HTTP server for the Tish interpreter. Client `fetch` uses `tishlang_runtime` from eval.
 
-use crate::value::Value;
-use std::collections::HashMap;
+use crate::value::{PropMap, Value};
 use std::sync::Arc;
 
 use tokio::runtime::Runtime;
@@ -22,7 +21,7 @@ pub fn create_server(port: u16) -> Result<tiny_http::Server, String> {
 
 /// Convert a tiny_http::Request into a Tish Value object.
 pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
-    let mut obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(6);
+    let mut obj: PropMap = PropMap::with_capacity(6);
 
     obj.insert(
         Arc::from("method"),
@@ -39,7 +38,7 @@ pub fn request_to_value(request: &mut tiny_http::Request) -> Value {
     let query_string = request.url().split('?').nth(1).unwrap_or("");
     obj.insert(Arc::from("query"), Value::String(query_string.into()));
 
-    let mut headers_obj: HashMap<Arc<str>, Value> = HashMap::with_capacity(request.headers().len());
+    let mut headers_obj: PropMap = PropMap::with_capacity(request.headers().len());
     for header in request.headers() {
         headers_obj.insert(
             Arc::from(header.field.as_str().as_str()),

package/crates/tish_eval/src/lib.rs

@@ -14,6 +14,7 @@ pub mod regex;
 mod value;
 
 pub use eval::Evaluator;
+pub use value::PropMap;
 pub use value::Value;
 
 /// Trait for pluggable native modules (e.g. Polars). Implement to register
@@ -21,6 +22,12 @@ pub use value::Value;
 pub trait TishNativeModule: Send + Sync {
     fn name(&self) -> &'static str;
     fn register(&self) -> std::collections::HashMap<std::sync::Arc<str>, Value>;
+
+    /// Virtual `tish:*` modules for `import { x } from 'tish:…'` (e.g. `tish:polars`).
+    /// Return `(specifier, exports_object)` pairs. Default: none.
+    fn virtual_builtin_modules(&self) -> Vec<(&'static str, Value)> {
+        vec![]
+    }
 }
 #[cfg(feature = "regex")]
 pub use regex::TishRegExp;