@tishlang/tish 1.0.29 → 1.0.33

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),
         }))
@@ -85,7 +85,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 +101,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 +122,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 +135,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);
@@ -323,14 +338,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,
                 };
@@ -536,7 +548,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);
@@ -576,7 +588,7 @@ impl Evaluator {
             "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 +607,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 +628,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 +645,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 +653,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));
@@ -1534,7 +1546,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,6 +1573,11 @@ 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(),
             )),
@@ -1577,7 +1594,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 +1771,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 +1783,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 +1875,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 +1963,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
     }
@@ -2002,12 +2030,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 +2108,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 +2193,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 +2217,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 +2239,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);
                     }
                 }
@@ -2449,13 +2512,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 +2554,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 +2596,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 +2618,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 +2823,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 +2951,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 +3026,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 +3038,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/regex.rs

@@ -3,12 +3,13 @@
 //! Re-exports core types from tishlang_core and provides interpreter-specific functionality.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
 pub use tishlang_core::{RegExpFlags, TishRegExp};
 
+use crate::value::PropMap;
+
 use crate::value::Value;
 
 /// RegExp.prototype.exec(string) - returns match object (array-like with index) or null
@@ -42,7 +43,7 @@ pub fn regexp_exec(re: &mut TishRegExp, input: &str) -> Value {
             let match_byte_start = byte_start + full_match.start();
             let match_char_index = input[..match_byte_start].chars().count();
 
-            let mut obj: HashMap<Arc<str>, Value> = HashMap::new();
+            let mut obj: PropMap = PropMap::default();
             obj.insert(Arc::from("0"), Value::String(full_match.as_str().into()));
             for i in 1..caps.len() {
                 let val = match caps.get(i) {

package/crates/tish_eval/src/value.rs

@@ -6,13 +6,15 @@
 //! different shape (no AST-carrying variants). The split is intentional.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
-use tishlang_ast::{Expr, Statement};
-#[cfg(any(feature = "http", feature = "ws"))]
+use ahash::AHashMap;
+use tishlang_ast::{FunParam, Statement};
 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>;
 #[cfg(feature = "http")]
 use tishlang_core::TishPromise;
 use tishlang_core::TishOpaque;
@@ -32,11 +34,10 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    Object(Rc<RefCell<PropMap>>),
     /// User-defined function with AST body
     Function {
-        params: Arc<[Arc<str>]>,
-        defaults: Arc<[Option<Expr>]>,
+        formals: Arc<[FunParam]>,
         rest_param: Option<Arc<str>>,
         body: Arc<Statement>,
     },
@@ -65,8 +66,7 @@ pub enum Value {
     /// Native `tishlang_core` Promise (fetch / reader.read / response.text).
     #[cfg(feature = "http")]
     CorePromise(Arc<dyn TishPromise>),
-    /// `tishlang_core::Value::Function` (e.g. response.text/json, ws send/receive) callable from eval.
-    #[cfg(any(feature = "http", feature = "ws"))]
+    /// `tishlang_core::Value::Function` (native callbacks, `new` constructors, fetch/ws when enabled).
     CoreFn(CoreNativeFn),
     /// Opaque handle to a native Rust type (e.g. Polars DataFrame).
     Opaque(Arc<dyn TishOpaque>),
@@ -99,7 +99,6 @@ impl std::fmt::Debug for Value {
             Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "Promise"),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(_) => write!(f, "CoreFn"),
             Value::Opaque(o) => write!(f, "{}(opaque)", o.type_name()),
             Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
@@ -155,7 +154,6 @@ impl std::fmt::Display for Value {
             Value::BoundPromiseMethod(_, _) | Value::TimerBuiltin(_) => write!(f, "[Function]"),
             #[cfg(feature = "http")]
             Value::CorePromise(_) => write!(f, "[Promise]"),
-            #[cfg(any(feature = "http", feature = "ws"))]
             Value::CoreFn(_) => write!(f, "[Function]"),
             Value::Opaque(o) => write!(f, "[object {}]", o.type_name()),
             Value::OpaqueMethod(_, _) => write!(f, "[Function]"),
@@ -199,8 +197,8 @@ impl Value {
         Value::Array(Rc::new(RefCell::new(items)))
     }
 
-    /// Create a new object Value from a HashMap.
-    pub fn object(map: HashMap<Arc<str>, Value>) -> Self {
+    /// Create a new object Value from a property map.
+    pub fn object(map: PropMap) -> Self {
         Value::Object(Rc::new(RefCell::new(map)))
     }
 
@@ -211,7 +209,7 @@ impl Value {
 
     /// Create an empty object Value.
     pub fn empty_object() -> Self {
-        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+        Value::Object(Rc::new(RefCell::new(PropMap::default())))
     }
 
     /// Extract the number value, if this is a Number.