@tishlang/tish 1.0.28 → 1.0.33

package/Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "crates/tish_eval",
     "crates/tish_runtime",
     "crates/tish_compile",
+    "crates/tish_ui",
     "crates/tish_jsx_web",
     "crates/tish_compile_js",
     "crates/tish_bytecode",

package/crates/js_to_tish/src/transform/expr.rs

@@ -6,7 +6,7 @@ use oxc::ast::ast::Expression as OxcExpr;
 use oxc::semantic::Semantic;
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CompoundOp, DestructPattern, Expr, Literal, LogicalAssignOp,
-    MemberProp, ObjectProp, TypedParam,
+    FunParam, MemberProp, ObjectProp, TypedParam,
 };
 
 use crate::error::{ConvertError, ConvertErrorKind};
@@ -73,6 +73,15 @@ pub fn convert_expr(expr: &OxcExpr<'_>, ctx: &Ctx<'_>) -> Result<Expr, ConvertEr
                 .collect::<Result<Vec<_>, _>>()?;
             Ok(Expr::Call { callee, args, span })
         }
+        OxcExpr::NewExpression(n) => {
+            let callee = Box::new(convert_expr(&n.callee, ctx)?);
+            let args = n
+                .arguments
+                .iter()
+                .map(|a| convert_call_arg(a, ctx))
+                .collect::<Result<Vec<_>, _>>()?;
+            Ok(Expr::New { callee, args, span })
+        }
         OxcExpr::StaticMemberExpression(s) => {
             let object = Box::new(convert_expr(&s.object, ctx)?);
             Ok(Expr::Member {
@@ -518,7 +527,7 @@ fn convert_unary_op(
 pub fn convert_params(
     params: &oxc::ast::ast::FormalParameters<'_>,
     ctx: &Ctx<'_>,
-) -> Result<(Vec<TypedParam>, Option<TypedParam>), ConvertError> {
+) -> Result<(Vec<FunParam>, Option<TypedParam>), ConvertError> {
     let mut typed_params = Vec::new();
     let mut rest_param = None;
     for (i, p) in params.items.iter().enumerate() {
@@ -558,11 +567,11 @@ pub fn convert_params(
                     .as_ref()
                     .map(|e| convert_expr(e, ctx))
                     .transpose()?;
-                typed_params.push(TypedParam {
+                typed_params.push(FunParam::Simple(TypedParam {
                     name: Arc::from(name),
                     type_ann: None,
                     default,
-                });
+                }));
         }
     }
     if rest_param.is_none() {
@@ -589,10 +598,10 @@ pub fn convert_params(
 fn convert_arrow_params(
     params: &oxc::ast::ast::FormalParameters<'_>,
     ctx: &Ctx<'_>,
-) -> Result<Vec<TypedParam>, ConvertError> {
+) -> Result<Vec<FunParam>, ConvertError> {
     let (mut ps, rest) = convert_params(params, ctx)?;
     if let Some(r) = rest {
-        ps.push(r);
+        ps.push(FunParam::Simple(r));
     }
     Ok(ps)
 }

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "1.0.28"
+version = "1.0.33"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }

package/crates/tish/src/main.rs

@@ -28,7 +28,7 @@ struct RunArgs {
     #[arg(long, default_value = "vm")]
     backend: String,
     /// Enable capabilities (http, fs, process, regex, ws). Must match how tish was built.
-    /// E.g. cargo run -p tish --features http,fs -- run script.tish --feature http,fs
+    /// E.g. cargo run -p tishlang--features http,fs -- run script.tish --feature http,fs
     #[arg(long = "feature", action = clap::ArgAction::Append)]
     features: Vec<String>,
     /// Disable AST and bytecode optimizations (for debugging)
@@ -56,9 +56,6 @@ struct CompileArgs {
     features: Vec<String>,
     #[arg(long)]
     no_optimize: bool,
-    /// JS target only: `lattish` (default), `vdom` (vnode + patch; use with Lattish createRoot).
-    #[arg(long = "jsx", value_name = "MODE", default_value = "lattish")]
-    jsx_mode: String,
     #[arg(required = true)]
     file: String,
 }
@@ -94,7 +91,6 @@ fn main() {
             &a.native_backend,
             &a.features,
             a.no_optimize || no_opt_env,
-            &a.jsx_mode,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => run_repl("vm", false), // No args = REPL
@@ -339,29 +335,7 @@ fn tish_history_path() -> Option<PathBuf> {
     home.map(|h| PathBuf::from(h).join(".tish_history"))
 }
 
-fn parse_jsx_mode(s: &str) -> Result<tishlang_compile_js::JsxMode, String> {
-    match s {
-        "legacy" => Err(
-            "--jsx legacy was removed. Use --jsx lattish (default) with lattish merged into your \
-             bundle, or --jsx vdom with Lattish's createRoot."
-                .to_string(),
-        ),
-        "vdom" => Ok(tishlang_compile_js::JsxMode::Vdom),
-        "lattish" => Ok(tishlang_compile_js::JsxMode::LattishH),
-        other => Err(format!(
-            "Unknown --jsx {:?}: use lattish (default) or vdom.",
-            other
-        )),
-    }
-}
-
-fn compile_to_js(
-    input_path: &Path,
-    output_path: &str,
-    optimize: bool,
-    jsx: &str,
-) -> Result<(), String> {
-    let jsx_mode = parse_jsx_mode(jsx)?;
+fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result<(), String> {
     let project_root = input_path.parent().and_then(|p| {
         if p.file_name().and_then(|n| n.to_str()) == Some("src") {
             p.parent()
@@ -382,13 +356,13 @@ fn compile_to_js(
         } else {
             program
         };
-        tishlang_compile_js::compile_with_jsx(&p, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        tishlang_compile_js::compile_with_jsx(&program, optimize, jsx_mode).map_err(|e| format!("{}", e))?
+        tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?
     } else {
-        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize, jsx_mode)
+        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
             .map_err(|e| format!("{}", e))?
     };
 
@@ -418,7 +392,6 @@ fn compile_file(
     native_backend: &str,
     cli_features: &[String],
     no_optimize: bool,
-    jsx: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path =
@@ -427,7 +400,7 @@ fn compile_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize, jsx.trim());
+        return compile_to_js(&input_path, output_path, optimize);
     }
 
     if target == "wasm" && is_js {
@@ -539,7 +512,7 @@ mod cli_tests {
     use super::{Cli, Commands};
 
     #[test]
-    fn compile_jsx_defaults_to_lattish() {
+    fn compile_js_target_parses() {
         let cli = Cli::try_parse_from([
             "tish",
             "compile",
@@ -551,27 +524,7 @@ mod cli_tests {
         ])
         .unwrap();
         match cli.command {
-            Some(Commands::Compile(a)) => assert_eq!(a.jsx_mode.as_str(), "lattish"),
-            _ => panic!("expected Compile"),
-        }
-    }
-
-    #[test]
-    fn compile_jsx_flag_vdom() {
-        let cli = Cli::try_parse_from([
-            "tish",
-            "compile",
-            "a.tish",
-            "--target",
-            "js",
-            "--jsx",
-            "vdom",
-            "-o",
-            "x.js",
-        ])
-        .unwrap();
-        match cli.command {
-            Some(Commands::Compile(a)) => assert_eq!(a.jsx_mode.as_str(), "vdom"),
+            Some(Commands::Compile(a)) => assert_eq!(a.file, "m.tish"),
             _ => panic!("expected Compile"),
         }
     }

package/crates/tish/tests/integration_test.rs

@@ -1,8 +1,8 @@
 //! Full-stack integration tests: run .tish files with interpreter or each backend and compare
 //! stdout to static expected files (e.g. `fn_any.tish.expected`).
 //!
-//! - Run: `cargo test -p tish` (or `cargo nextest run -p tish`).
-//! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tish test_mvp_programs_interpreter`
+//! - Run: `cargo test -p tishlang` (or `cargo nextest run -p tishlang`).
+//! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tishlangtest_mvp_programs_interpreter`
 //!   then commit the new/updated `tests/core/*.tish.expected` files.
 //! - Compiled outputs are cached under `target/integration_compile_cache/` per backend.
 
@@ -232,7 +232,7 @@ fn test_async_await_compile_via_binary() {
 /// Uses httpbin.org/delay/1 (1s each). 3 parallel ≈ 1s, 3 sequential ≈ 3s.
 #[test]
 #[cfg(feature = "http")]
-#[ignore = "timing and network sensitive; run manually: cargo test test_async_parallel_vs_sequential_timing -p tish --features http -- --ignored"]
+#[ignore = "timing and network sensitive; run manually: cargo test test_async_parallel_vs_sequential_timing -p tishlang--features http -- --ignored"]
 fn test_async_parallel_vs_sequential_timing() {
     let bin = tish_bin();
     let parallel_src = workspace_root().join("examples").join("async-await").join("src").join("parallel.tish");
@@ -474,6 +474,7 @@ const MVP_TEST_FILES: &[&str] = &[
     "types.tish",
     "logical_assign.tish",
     "spread.tish",
+    "fn_param_destructuring.tish",
 ];
 
 /// Run each .tish file with interpreter and compare stdout to static expected.

package/crates/tish_ast/src/ast.rs

@@ -34,6 +34,62 @@ pub struct TypedParam {
     pub default: Option<Expr>,
 }
 
+
+/// Single formal parameter: simple identifier or destructuring pattern.
+#[derive(Debug, Clone, PartialEq)]
+pub enum FunParam {
+    Simple(TypedParam),
+    Destructure {
+        pattern: DestructPattern,
+        type_ann: Option<TypeAnnotation>,
+        default: Option<Expr>,
+    },
+}
+
+
+impl FunParam {
+    /// Variable names introduced by this formal parameter.
+    pub fn bound_names(&self) -> Vec<Arc<str>> {
+        let mut out = Vec::new();
+        match self {
+            FunParam::Simple(tp) => out.push(Arc::clone(&tp.name)),
+            FunParam::Destructure { pattern, .. } => {
+                Self::collect_pattern_binding_names(pattern, &mut out);
+            }
+        }
+        out
+    }
+
+    fn collect_pattern_binding_names(pattern: &DestructPattern, out: &mut Vec<Arc<str>>) {
+        match pattern {
+            DestructPattern::Array(elements) => {
+                for el in elements {
+                    if let Some(el) = el {
+                        match el {
+                            DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                            DestructElement::Pattern(p) => {
+                                Self::collect_pattern_binding_names(p, out);
+                            }
+                            DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                        }
+                    }
+                }
+            }
+            DestructPattern::Object(props) => {
+                for prop in props {
+                    match &prop.value {
+                        DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                        DestructElement::Pattern(p) => {
+                            Self::collect_pattern_binding_names(p, out);
+                        }
+                        DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// Destructuring pattern for array or object destructuring
 #[derive(Debug, Clone, PartialEq)]
 pub enum DestructPattern {
@@ -149,7 +205,7 @@ pub enum Statement {
     FunDecl {
         async_: bool,
         name: Arc<str>,
-        params: Vec<TypedParam>,
+        params: Vec<FunParam>,
         rest_param: Option<TypedParam>,
         return_type: Option<TypeAnnotation>,
         body: Box<Statement>,
@@ -214,6 +270,12 @@ pub enum Expr {
         args: Vec<CallArg>,
         span: Span,
     },
+    /// `new` expression (JavaScript target). `callee` is the constructor reference; `args` may be empty.
+    New {
+        callee: Box<Expr>,
+        args: Vec<CallArg>,
+        span: Span,
+    },
     Member {
         object: Box<Expr>,
         prop: MemberProp,
@@ -298,7 +360,7 @@ pub enum Expr {
     },
     /// Arrow function: (params) => body
     ArrowFunction {
-        params: Vec<TypedParam>,
+        params: Vec<FunParam>,
         body: ArrowBody,
         span: Span,
     },
@@ -374,6 +436,7 @@ impl Expr {
             Expr::Binary { span, .. } => *span,
             Expr::Unary { span, .. } => *span,
             Expr::Call { span, .. } => *span,
+            Expr::New { span, .. } => *span,
             Expr::Member { span, .. } => *span,
             Expr::Index { span, .. } => *span,
             Expr::Conditional { span, .. } => *span,

package/crates/tish_build_utils/src/lib.rs

@@ -7,6 +7,14 @@ use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
+/// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
+///
+/// Used so we do not treat unrelated workspaces (e.g. a parent `zectre-platform` repo) as Tish
+/// when `CARGO_MANIFEST_DIR` or cwd points at another Rust workspace.
+fn is_tish_workspace_root(root: &Path) -> bool {
+    root.join("crates").join("tish_runtime").is_dir()
+}
+
 /// Find the Tish workspace root using multiple strategies.
 ///
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
@@ -18,7 +26,7 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
         // For crates/tish_*, workspace root is parent.parent()
         if let Some(root) = path.parent().and_then(|p| p.parent()) {
             let root_buf = root.to_path_buf();
-            if root_buf.join("Cargo.toml").exists() {
+            if root_buf.join("Cargo.toml").exists() && is_tish_workspace_root(&root_buf) {
                 return Ok(root_buf);
             }
         }
@@ -47,7 +55,7 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
             let cargo_toml = current.join("Cargo.toml");
             if cargo_toml.exists() {
                 if let Ok(content) = std::fs::read_to_string(&cargo_toml) {
-                    if content.contains("[workspace]") {
+                    if content.contains("[workspace]") && is_tish_workspace_root(&current) {
                         return Ok(current);
                     }
                 }

package/crates/tish_builtins/src/construct.rs

@@ -0,0 +1,177 @@
+//! `new` lowering for non-JS targets: `construct(callee, args)` approximates JS `[[Construct]]`.
+//! Browser-exact behavior remains on `tish compile --target js`.
+
+use std::cell::RefCell;
+use std::rc::Rc;
+use std::sync::Arc;
+
+use tishlang_core::{ObjectMap, Value};
+
+const CONSTRUCT: &str = "__construct";
+
+/// Host `new`: `Object` with `__construct`, `Function` as plain call, else `Null`.
+pub fn construct(callee: &Value, args: &[Value]) -> Value {
+    match callee {
+        Value::Function(f) => f(args),
+        Value::Object(o) => {
+            let b = o.borrow();
+            if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
+                let c = Rc::clone(ctor);
+                drop(b);
+                return c(args);
+            }
+            Value::Null
+        }
+        _ => Value::Null,
+    }
+}
+
+fn param(initial: f64) -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("value"), Value::Number(initial));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn connect_fn() -> Value {
+    Value::Function(Rc::new(|_| Value::Null))
+}
+
+/// Shared audio-node shape: connect, gain, optional filter fields.
+fn audio_node_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("gain"), param(0.0));
+    m.insert(Arc::from("frequency"), param(440.0));
+    m.insert(Arc::from("Q"), param(1.0));
+    m.insert(Arc::from("type"), Value::String("peaking".into()));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn analyser_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("fftSize"), Value::Number(2048.0));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn stereo_panner_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(Arc::from("pan"), param(0.0));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn audio_buffer_stub(len: usize) -> Value {
+    let n = len.max(1);
+    let data = Rc::new(RefCell::new(vec![Value::Number(0.0); n]));
+    let data2 = Rc::clone(&data);
+    let mut m = ObjectMap::default();
+    m.insert(
+        Arc::from("getChannelData"),
+        Value::Function(Rc::new(move |_args| Value::Array(Rc::clone(&data2)))),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn buffer_source_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("buffer"), Value::Null);
+    m.insert(Arc::from("loop"), Value::Bool(false));
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(
+        Arc::from("start"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    m.insert(
+        Arc::from("stop"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn oscillator_stub() -> Value {
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from("frequency"), param(440.0));
+    m.insert(Arc::from("type"), Value::String("sine".into()));
+    m.insert(Arc::from("connect"), connect_fn());
+    m.insert(
+        Arc::from("start"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    m.insert(
+        Arc::from("stop"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+fn audio_context_instance() -> Value {
+    let mut ctx = ObjectMap::default();
+    ctx.insert(Arc::from("sampleRate"), Value::Number(48_000.0));
+    ctx.insert(Arc::from("destination"), audio_node_stub());
+
+    ctx.insert(
+        Arc::from("createGain"),
+        Value::Function(Rc::new(|_| audio_node_stub())),
+    );
+    ctx.insert(
+        Arc::from("createBiquadFilter"),
+        Value::Function(Rc::new(|_| audio_node_stub())),
+    );
+    ctx.insert(
+        Arc::from("createStereoPanner"),
+        Value::Function(Rc::new(|_| stereo_panner_stub())),
+    );
+    ctx.insert(
+        Arc::from("createAnalyser"),
+        Value::Function(Rc::new(|_| analyser_stub())),
+    );
+    ctx.insert(
+        Arc::from("createBuffer"),
+        Value::Function(Rc::new(|args: &[Value]| {
+            let len = args
+                .get(1)
+                .and_then(Value::as_number)
+                .unwrap_or(0.0)
+                .clamp(0.0, 1_000_000_000.0) as usize;
+            audio_buffer_stub(len)
+        })),
+    );
+    ctx.insert(
+        Arc::from("createBufferSource"),
+        Value::Function(Rc::new(|_| buffer_source_stub())),
+    );
+    ctx.insert(
+        Arc::from("createOscillator"),
+        Value::Function(Rc::new(|_| oscillator_stub())),
+    );
+    ctx.insert(
+        Arc::from("decodeAudioData"),
+        Value::Function(Rc::new(|_| Value::Null)),
+    );
+
+    Value::Object(Rc::new(RefCell::new(ctx)))
+}
+
+/// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
+pub fn uint8_array_constructor_value() -> Value {
+    let ctor = Rc::new(|args: &[Value]| {
+        let len = args
+            .first()
+            .and_then(Value::as_number)
+            .unwrap_or(0.0)
+            .clamp(0.0, 1_000_000_000.0) as usize;
+        Value::Array(Rc::new(RefCell::new(vec![Value::Number(0.0); len])))
+    });
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
+    Value::Object(Rc::new(RefCell::new(m)))
+}
+
+/// Global `AudioContext` for native/VM: stub graph (no real audio).
+pub fn audio_context_constructor_value() -> Value {
+    let ctor = Rc::new(|_args: &[Value]| audio_context_instance());
+    let mut m = ObjectMap::default();
+    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
+    Value::Object(Rc::new(RefCell::new(m)))
+}

package/crates/tish_builtins/src/globals.rs

@@ -4,10 +4,9 @@
 //! independent of tishlang_runtime.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::{percent_decode, percent_encode, Value};
+use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
 
 /// Boolean(value) - coerce to bool
 pub fn boolean(args: &[Value]) -> Value {
@@ -174,8 +173,7 @@ pub fn parse_float(args: &[Value]) -> Value {
 pub fn object_from_entries(args: &[Value]) -> Value {
     if let Some(Value::Array(entries)) = args.first() {
         let entries_borrow = entries.borrow();
-        let mut obj: HashMap<Arc<str>, Value> =
-            HashMap::with_capacity(entries_borrow.len());
+        let mut obj: ObjectMap = ObjectMap::with_capacity(entries_borrow.len());
 
         for entry in entries_borrow.iter() {
             if let Value::Array(pair) = entry {
@@ -192,6 +190,6 @@ pub fn object_from_entries(args: &[Value]) -> Value {
 
         Value::Object(Rc::new(RefCell::new(obj)))
     } else {
-        Value::Object(Rc::new(RefCell::new(HashMap::new())))
+        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
     }
 }

package/crates/tish_builtins/src/helpers.rs

@@ -1,10 +1,9 @@
 //! Common helper functions used across builtin implementations.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Normalize an array index, handling negative indices.
 /// Returns a valid index within bounds or the default value.
@@ -24,7 +23,7 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 
 /// Create an error object with a single "error" field.
 pub fn make_error_value(e: impl std::fmt::Display) -> Value {
-    let mut obj = HashMap::with_capacity(1);
+    let mut obj = ObjectMap::with_capacity(1);
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
     Value::Object(Rc::new(RefCell::new(obj)))
 }

package/crates/tish_builtins/src/lib.rs

@@ -10,5 +10,6 @@ pub mod object;
 pub mod math;
 pub mod helpers;
 pub mod globals;
+pub mod construct;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/object.rs

@@ -4,19 +4,18 @@
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
-use tishlang_core::Value;
+use tishlang_core::{ObjectMap, Value};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
-    Value::Object(Rc::new(RefCell::new(HashMap::new())))
+    Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
 }
 
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
-    Value::Object(Rc::new(RefCell::new(HashMap::with_capacity(capacity))))
+    Value::Object(Rc::new(RefCell::new(ObjectMap::with_capacity(capacity))))
 }
 
 /// Get the keys of an object.