@tishlang/tish 1.0.28 → 1.0.33

package/crates/tish_compile_js/Cargo.toml

@@ -10,8 +10,8 @@ repository = { workspace = true }
 default = []
 
 [dependencies]
-tishlang_jsx_web = { path = "../tish_jsx_web", version = ">=0.1" }
 tishlang_ast = { path = "../tish_ast", version = ">=0.1" }
 tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
+tishlang_ui = { path = "../tish_ui", default-features = false, features = ["compiler"] }

package/crates/tish_compile_js/src/codegen.rs

@@ -2,30 +2,15 @@
 
 use tishlang_ast::{
     ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
-    JsxAttrValue, JsxChild, JsxProp, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program,
-    Statement, UnaryOp,
+    FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
 };
 
 use crate::error::CompileError;
-use crate::js_intrinsics::{JsIntrinsic, JsIntrinsics};
-
-/// How JSX lowers for `--target js`. Native targets never use this.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum JsxMode {
-    /// `h(tag, props, [children])` + `Fragment` (Lattish.tish). Import `h` / `Fragment` from lattish.
-    #[default]
-    LattishH,
-    /// Vnode `__vdom_h` + `window.__lattishVdomPatch` (Lattish createRoot must use patch).
-    Vdom,
-}
 
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
-    uses_jsx: bool,
-    intrinsics: JsIntrinsics,
-    jsx_mode: JsxMode,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -36,14 +21,11 @@ fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
 }
 
 impl Codegen {
-    fn new(jsx_mode: JsxMode) -> Self {
+    fn new() -> Self {
         Self {
             output: String::new(),
             indent: 0,
             in_async: false,
-            uses_jsx: false,
-            intrinsics: JsIntrinsics::new(),
-            jsx_mode,
         }
     }
 
@@ -72,25 +54,9 @@ impl Codegen {
 
     fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
-        // First pass: check if JSX is used (we'll set uses_jsx during emit)
         for stmt in &program.statements {
             self.emit_statement(stmt)?;
         }
-        self.output = self
-            .intrinsics
-            .prepend_runtime_preamble(std::mem::take(&mut self.output));
-        if self.uses_jsx {
-            match self.jsx_mode {
-                JsxMode::Vdom => {
-                    self.output = format!(
-                        "{}\n{}",
-                        tishlang_jsx_web::VDOM_PRELUDE,
-                        self.output
-                    );
-                }
-                JsxMode::LattishH => {}
-            }
-        }
         Ok(())
     }
 
@@ -331,20 +297,34 @@ impl Codegen {
 
     fn emit_params(
         &mut self,
-        params: &[tishlang_ast::TypedParam],
+        params: &[FunParam],
         rest_param: Option<&tishlang_ast::TypedParam>,
     ) -> Result<String, CompileError> {
-        let mut parts: Vec<String> = params
-            .iter()
-            .map(|p| {
-                let n = Self::escape_ident(p.name.as_ref());
-                if let Some(ref d) = p.default {
-                    format!("{} = {}", n, self.emit_expr(d).unwrap())
-                } else {
-                    n
+        let mut parts: Vec<String> = Vec::new();
+        for p in params {
+            match p {
+                FunParam::Simple(tp) => {
+                    let n = Self::escape_ident(tp.name.as_ref());
+                    let s = if let Some(ref d) = tp.default {
+                        format!("{} = {}", n, self.emit_expr(d)?)
+                    } else {
+                        n
+                    };
+                    parts.push(s);
                 }
-            })
-            .collect();
+                FunParam::Destructure {
+                    pattern,
+                    type_ann: _,
+                    default,
+                } => {
+                    let mut s = self.emit_destruct_pattern(pattern)?;
+                    if let Some(ref d) = default {
+                        s = format!("{} = {}", s, self.emit_expr(d)?);
+                    }
+                    parts.push(s);
+                }
+            }
+        }
         if let Some(rest) = rest_param {
             parts.push(format!("...{}", Self::escape_ident(rest.name.as_ref())));
         }
@@ -448,16 +428,6 @@ impl Codegen {
                 }
             }
             Expr::Call { callee, args, .. } => {
-                if let Some(kind) =
-                    JsIntrinsics::classify_call(callee.as_ref(), args)?
-                {
-                    self.intrinsics.mark(kind);
-                    if kind == JsIntrinsic::Uint8Array {
-                        let n = self.emit_call_arg(&args[0])?;
-                        return Ok(JsIntrinsics::emit_expr(kind, &n));
-                    }
-                    return Ok(JsIntrinsics::emit_expr(kind, ""));
-                }
                 let c = self.emit_expr(callee)?;
                 let arg_strs: Result<Vec<_>, _> =
                     args.iter().map(|a| self.emit_call_arg(a)).collect();
@@ -465,6 +435,13 @@ impl Codegen {
                 // Tish uses null for undefined (e.g. empty array pop/shift)
                 format!("({}({}) ?? null)", c, arg_strs)
             }
+            Expr::New { callee, args, .. } => {
+                let c = self.emit_expr(callee)?;
+                let arg_strs: Result<Vec<_>, _> =
+                    args.iter().map(|a| self.emit_call_arg(a)).collect();
+                let arg_strs = arg_strs?.join(", ");
+                format!("(new {}({}) ?? null)", c, arg_strs)
+            }
             Expr::Member {
                 object,
                 prop,
@@ -652,39 +629,11 @@ impl Codegen {
                 let o = self.emit_expr(operand)?;
                 format!("(await {})", o)
             }
-            Expr::JsxElement { tag, props, children, .. } => {
-                self.uses_jsx = true;
-                let tag_str = if tag.chars().next().map(|c| c.is_uppercase()).unwrap_or(false) {
-                    tag.as_ref().to_string()
-                } else {
-                    format!("{:?}", tag.as_ref())
-                };
-                let props_str = self.emit_jsx_props(props)?;
-                let children_strs: Result<Vec<_>, _> =
-                    children.iter().map(|c| self.emit_jsx_child(c)).collect();
-                let children_str = children_strs?.join(", ");
-                match self.jsx_mode {
-                    JsxMode::LattishH => {
-                        format!("h({}, {}, [{}])", tag_str, props_str, children_str)
-                    }
-                    JsxMode::Vdom => {
-                        format!("__vdom_h({}, {}, [{}])", tag_str, props_str, children_str)
-                    }
-                }
-            }
-            Expr::JsxFragment { children, .. } => {
-                self.uses_jsx = true;
-                let children_strs: Result<Vec<_>, _> =
-                    children.iter().map(|c| self.emit_jsx_child(c)).collect();
-                let children_str = children_strs?.join(", ");
-                match self.jsx_mode {
-                    JsxMode::LattishH => {
-                        format!("h(Fragment, null, [{}])", children_str)
-                    }
-                    JsxMode::Vdom => {
-                        format!("__vdom_h(__Fragment, null, [{}])", children_str)
-                    }
-                }
+            Expr::JsxElement { .. } | Expr::JsxFragment { .. } => {
+                tishlang_ui::jsx::emit_jsx_js(expr, &mut |e| {
+                    self.emit_expr(e).map_err(|ce| ce.message)
+                })
+                .map_err(|m| CompileError { message: m })?
             }
             Expr::NativeModuleLoad { spec, .. } => {
                 return Err(CompileError {
@@ -704,68 +653,16 @@ impl Codegen {
         }
     }
 
-    fn emit_jsx_props(&mut self, props: &[JsxProp]) -> Result<String, CompileError> {
-        if props.is_empty() {
-            return Ok("null".to_string());
-        }
-        let parts: Result<Vec<_>, _> = props
-            .iter()
-            .map(|p| match p {
-                JsxProp::Attr { name, value } => {
-                    let val = match value {
-                        JsxAttrValue::String(s) => format!("{:?}", s.as_ref()),
-                        JsxAttrValue::Expr(e) => self.emit_expr(e)?,
-                        JsxAttrValue::ImplicitTrue => "true".to_string(),
-                    };
-                    let key = name.as_ref();
-                    Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
-                        format!("{}: {}", key, val)
-                    } else {
-                        format!("{:?}: {}", key, val)
-                    })
-                }
-                JsxProp::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
-            })
-            .collect();
-        Ok(format!("{{ {} }}", parts?.join(", ")))
-    }
-
-    fn emit_jsx_child(&mut self, child: &JsxChild) -> Result<String, CompileError> {
-        match child {
-            JsxChild::Text(s) => Ok(format!("{:?}", s.as_ref())),
-            JsxChild::Expr(e) => {
-                let inner = self.emit_expr(e)?;
-                // Only wrap literals we know are primitives (number, bool, null). Never wrap:
-                // string/template (already strings), JSX (elements), Call (components), Array/Ident (may hold elements).
-                let needs_string = matches!(
-                    e,
-                    Expr::Literal {
-                        value: Literal::Number(_) | Literal::Bool(_) | Literal::Null,
-                        ..
-                    }
-                );
-                Ok(if needs_string {
-                    format!("String({})", inner)
-                } else {
-                    inner
-                })
-            }
-        }
-    }
 }
 
-/// Compile a single program (no imports) to JavaScript.
-pub fn compile_with_jsx(
-    program: &Program,
-    optimize: bool,
-    jsx_mode: JsxMode,
-) -> Result<String, CompileError> {
+/// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
+pub fn compile_with_jsx(program: &Program, optimize: bool) -> Result<String, CompileError> {
     let program = if optimize {
         tishlang_opt::optimize(program)
     } else {
         program.clone()
     };
-    let mut g = Codegen::new(jsx_mode);
+    let mut g = Codegen::new();
     g.emit_program(&program)?;
     Ok(g.output)
 }
@@ -776,7 +673,6 @@ pub fn compile_project_with_jsx(
     entry_path: &std::path::Path,
     project_root: Option<&std::path::Path>,
     optimize: bool,
-    jsx_mode: JsxMode,
 ) -> Result<String, CompileError> {
     use tishlang_ast::Statement;
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
@@ -802,7 +698,7 @@ pub fn compile_project_with_jsx(
             None
         }
     });
-    let mut js = compile_with_jsx(&program, optimize, jsx_mode)?;
+    let mut js = compile_with_jsx(&program, optimize)?;
     if let Some(name) = default_export {
         js.push_str(&format!("\nexport default {};\n", name));
     }

package/crates/tish_compile_js/src/lib.rs

@@ -3,19 +3,16 @@
 
 mod codegen;
 mod error;
-mod js_intrinsics;
 
 #[cfg(test)]
 mod tests_jsx;
 
-pub use codegen::{compile_project_with_jsx, compile_with_jsx, JsxMode};
+pub use codegen::{compile_project_with_jsx, compile_with_jsx};
 pub use error::CompileError;
 
-/// Default JSX mode lowers to Lattish-style calls (implementation detail). Import what you use from
-/// `lattish` (e.g. `useState`, `createRoot`); the merged bundle includes the JSX runtime from that
-/// module. JSX-only files can use `import {} from "lattish"` to pull it in without bindings.
+/// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.
 pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
-    compile_with_jsx(program, optimize, JsxMode::LattishH)
+    compile_with_jsx(program, optimize)
 }
 
 pub fn compile_project(
@@ -23,5 +20,5 @@ pub fn compile_project(
     project_root: Option<&std::path::Path>,
     optimize: bool,
 ) -> Result<String, CompileError> {
-    compile_project_with_jsx(entry_path, project_root, optimize, JsxMode::LattishH)
+    compile_project_with_jsx(entry_path, project_root, optimize)
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,13 +4,13 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_with_jsx, compile_with_jsx, JsxMode};
+    use crate::{compile_project_with_jsx, compile_with_jsx};
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
         let src = r#"fn X() { return <div class="a">{"hi"}</div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("h(\"div\", { class: \"a\" }, [\"hi\"])"), "{}", js);
         assert!(!js.contains("function __h("));
     }
@@ -19,7 +19,7 @@ mod tests {
     fn fragment_lattish_uses_fragment_symbol() {
         let src = "fn X() { return <><b>{\"1\"}</b></> }";
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("h(Fragment, null, ["));
     }
 
@@ -27,7 +27,7 @@ mod tests {
     fn jsx_text_whitespace_coalesced() {
         let src = r#"fn X() { return <p>First paragraph</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("\"First paragraph\""),
             "expected \"First paragraph\" in output, got: {}",
@@ -43,7 +43,7 @@ mod tests {
     fn jsx_text_whitespace_coalesced_multiline() {
         let src = "fn App() {\n  return <p>First paragraph</p>\n}";
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("\"First paragraph\""),
             "multiline: expected \"First paragraph\", got: {}",
@@ -56,7 +56,7 @@ mod tests {
         // Punctuation (e.g. !) concatenates without space: "work!" not "work !"
         let src = r#"fn X() { return <p>work!</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains(r#""work!""#), "expected 'work!', got: {}", &js[..400.min(js.len())]);
     }
 
@@ -64,7 +64,7 @@ mod tests {
     fn jsx_text_emojis() {
         let src = r#"fn X() { return <p>hello 😔</p> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(js.contains("😔"), "expected emoji, got: {}", &js[..400.min(js.len())]);
     }
 
@@ -78,7 +78,7 @@ mod tests {
         f.write_all(src.as_bytes()).unwrap();
         f.sync_all().unwrap();
         drop(f);
-        let js = compile_project_with_jsx(&path, Some(&dir), false, JsxMode::LattishH)
+        let js = compile_project_with_jsx(&path, Some(&dir), false)
             .expect("compile_project_with_jsx failed");
         assert!(
             js.contains("\"First paragraph\""),
@@ -89,12 +89,14 @@ mod tests {
     }
 
     #[test]
-    fn vdom_emits_vdom_h() {
-        let src = r#"fn X() { return <p/> }"#;
+    fn jsx_never_emits_vdom_helpers_or_prelude_flags() {
+        let src = r#"fn X() { return <div class="x">{"a"}</div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::Vdom).unwrap();
-        assert!(js.contains("__vdom_h(\"p\", null, [])"), "{}", &js[..600.min(js.len())]);
-        assert!(js.contains("__lattishVdomPatch"));
+        let js = compile_with_jsx(&program, false).unwrap();
+        assert!(js.contains("h(\"div\", { class: \"x\" }"), "{}", &js[..500.min(js.len())]);
+        assert!(!js.contains("__vdom_h"), "{}", &js[..600.min(js.len())]);
+        assert!(!js.contains("window.__LATTISH_JSX_VDOM"), "{}", &js[..600.min(js.len())]);
+        assert!(!js.contains("__lattishVdomPatch"), "{}", &js[..600.min(js.len())]);
     }
 
     /// Component calls like {Panel()} return DOM elements. Wrapping in String() produces [object HTMLDivElement].
@@ -105,7 +107,7 @@ fn Panel() { return <div class="p">content</div> }
 fn App() { return <div>{Panel()}</div> }
 "#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("Panel()"),
             "component call should appear as Panel(), got: {}",
@@ -123,7 +125,7 @@ fn App() { return <div>{Panel()}</div> }
     fn jsx_nested_element_not_wrapped_in_string() {
         let src = r#"fn X() { return <div><span>inner</span></div> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             !js.contains("String(h("),
             "nested JSX elements must NOT be wrapped in String(). got: {}",
@@ -136,7 +138,7 @@ fn App() { return <div>{Panel()}</div> }
     fn jsx_literal_number_wrapped_in_string() {
         let src = r#"fn X() { return <span>{42}</span> }"#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             js.contains("String(42)"),
             "literal number in JSX should be wrapped in String(). got: {}",
@@ -156,7 +158,7 @@ fn FileList() {
 }
 "#;
         let program = parse(src).unwrap();
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).unwrap();
+        let js = compile_with_jsx(&program, false).unwrap();
         assert!(
             !js.contains("String(items)"),
             "array/ident in JSX must NOT be wrapped in String() - causes [object HTMLButtonElement]. got: {}",
@@ -177,7 +179,7 @@ fn FileList() {
   >{"ok"}</button>
 }"#;
         let program = parse(src).expect("parse multi-line JSX with > comparison in attr");
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).expect("compile");
+        let js = compile_with_jsx(&program, false).expect("compile");
         assert!(
             js.contains("length > 0") || js.contains("length>0"),
             "expected compiled JS to preserve greater-than comparison, got: {}",
@@ -197,7 +199,7 @@ fn FileList() {
   >{"outer"}</button>
 }"#;
         let program = parse(src).expect("parse nested JSX inside onclick");
-        let js = compile_with_jsx(&program, false, JsxMode::LattishH).expect("compile");
+        let js = compile_with_jsx(&program, false).expect("compile");
         assert!(
             js.contains("\"inner\""),
             "expected nested span text in output, got: {}",
@@ -209,4 +211,72 @@ fn FileList() {
             &js[..900.min(js.len())]
         );
     }
+
+    #[test]
+    fn new_date_global_emits_valid_js_with_and_without_optimize() {
+        let src = "let epoch = new Date(0)\nconsole.log(epoch.getTime())";
+        let program = parse(src).expect("parse");
+        for optimize in [false, true] {
+            let js = compile_with_jsx(&program, optimize).expect("compile");
+            assert!(
+                js.contains("new Date(0)"),
+                "optimize={optimize}: expected `new Date(0)` in JS output:\n{js}"
+            );
+            assert!(
+                !js.contains("let epoch = new;"),
+                "optimize={optimize}: broken `new` emission (missing constructor):\n{js}"
+            );
+        }
+    }
+
+    #[test]
+    fn new_uint8array_emits_direct_new_no_preamble() {
+        let src = "fn f(n) { return new Uint8Array(n) }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new Uint8Array("),
+            "expected direct new Uint8Array, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishUint8Array"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_audio_context_emits_direct_new_no_preamble() {
+        let src = "fn f() { return new AudioContext() }";
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new AudioContext("),
+            "expected new AudioContext, got: {}",
+            &js[..500.min(js.len())]
+        );
+        assert!(
+            !js.contains("__tishWebAudioCreateContext"),
+            "should not emit legacy intrinsic helper"
+        );
+    }
+
+    #[test]
+    fn new_class_name_emits_direct_new_js() {
+        let src = r#"
+fn ClassName(x) {
+    return x
+}
+fn factory() {
+    return new ClassName(42)
+}
+"#;
+        let program = parse(src).expect("parse");
+        let js = compile_with_jsx(&program, false).expect("compile");
+        assert!(
+            js.contains("new ClassName("),
+            "expected new ClassName( in JS output, got: {}",
+            &js[..800.min(js.len())]
+        );
+    }
 }

package/crates/tish_compiler_wasm/src/lib.rs

@@ -10,7 +10,6 @@ mod resolve_virtual;
 use base64::Engine;
 use resolve_virtual::{detect_cycles_virtual, merge_modules_virtual, resolve_virtual};
 use std::collections::HashMap;
-use tishlang_compile_js::JsxMode;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
@@ -24,7 +23,7 @@ pub fn compile_to_bytecode(source: &str) -> Result<String, JsValue> {
 #[wasm_bindgen]
 pub fn compile_to_js(source: &str) -> Result<String, JsValue> {
     let program = tishlang_parser::parse(source.trim()).map_err(|e| JsValue::from_str(&e.to_string()))?;
-    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    tishlang_compile_js::compile_with_jsx(&program, true)
         .map_err(|e| JsValue::from_str(&e.message))
 }
 
@@ -50,6 +49,6 @@ pub fn compile_to_js_with_imports(entry_path: &str, files_json: &str) -> Result<
     detect_cycles_virtual(&modules).map_err(|e| JsValue::from_str(&e))?;
     let program = merge_modules_virtual(modules).map_err(|e| JsValue::from_str(&e))?;
     let program = tishlang_opt::optimize(&program);
-    tishlang_compile_js::compile_with_jsx(&program, true, JsxMode::LattishH)
+    tishlang_compile_js::compile_with_jsx(&program, true)
         .map_err(|e| JsValue::from_str(&e.message))
 }

package/crates/tish_core/Cargo.toml

@@ -11,4 +11,8 @@ default = []
 regex = ["dep:fancy-regex"]
 
 [dependencies]
+ahash = "0.8.11"
 fancy-regex = { version = "0.17.0", optional = true }
+
+[target.wasm32-unknown-unknown.dependencies]
+getrandom = { version = "0.3", features = ["wasm_js"] }

package/crates/tish_core/src/console_style.rs

@@ -4,9 +4,12 @@
 //! booleans, null, and object structure are easier to scan.
 
 use std::io::IsTerminal;
+use std::sync::OnceLock;
 
 use crate::Value;
 
+static CONSOLE_USES_COLORS: OnceLock<bool> = OnceLock::new();
+
 /// ANSI escape codes (standard 4-bit + bright black for dim).
 const RESET: &str = "\x1b[0m";
 /// Number: yellow (Node-style)
@@ -25,8 +28,11 @@ const PUNCT: &str = "\x1b[90m";
 const SPECIAL: &str = "\x1b[90m";
 
 /// Returns whether console output should use colors (stdout is a TTY).
+///
+/// Cached for the process lifetime. `is_terminal()` is a syscall; benchmarks and
+/// scripts with many `console.log` calls must not pay it on every line.
 pub fn use_console_colors() -> bool {
-    std::io::stdout().is_terminal()
+    *CONSOLE_USES_COLORS.get_or_init(|| std::io::stdout().is_terminal())
 }
 
 /// Format a single value for console with optional ANSI colors (Node/Bun-style).

package/crates/tish_core/src/json.rs

@@ -2,7 +2,6 @@
 
 use crate::Value;
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -260,7 +259,7 @@ fn parse_array(input: &str) -> Result<(Value, &str), String> {
 
 fn parse_object(input: &str) -> Result<(Value, &str), String> {
     let mut input = &input[1..]; // skip '{'
-    let mut map = HashMap::new();
+    let mut map = crate::ObjectMap::default();
 
     input = input.trim_start();
     if let Some(rest) = input.strip_prefix('}') {

package/crates/tish_core/src/macros.rs

@@ -24,11 +24,10 @@
 macro_rules! tish_module {
     ($($name:expr => $fn:expr),* $(,)?) => {{
         use std::cell::RefCell;
-        use std::collections::HashMap;
         use std::rc::Rc;
         use std::sync::Arc;
-        use $crate::Value;
-        let mut map = HashMap::new();
+        use $crate::{ObjectMap, Value};
+        let mut map = ObjectMap::default();
         $(
             map.insert(Arc::from($name), Value::Function(Rc::new($fn)));
         )*

package/crates/tish_core/src/value.rs

@@ -1,10 +1,15 @@
 //! Unified Value type for Tish runtime values.
 
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::rc::Rc;
 use std::sync::Arc;
 
+use ahash::AHashMap;
+
+/// Property map for objects and other `Arc<str>` → `Value` tables (VM globals, scopes).
+/// Uses a faster hasher than `std::collections::HashMap` for string-heavy workloads.
+pub type ObjectMap = AHashMap<Arc<str>, Value>;
+
 #[cfg(feature = "regex")]
 use fancy_regex::Regex;
 
@@ -147,7 +152,7 @@ pub enum Value {
     Bool(bool),
     Null,
     Array(Rc<RefCell<Vec<Value>>>),
-    Object(Rc<RefCell<HashMap<Arc<str>, Value>>>),
+    Object(Rc<RefCell<ObjectMap>>),
     Function(NativeFn),
     #[cfg(feature = "regex")]
     RegExp(Rc<RefCell<TishRegExp>>),
@@ -256,8 +261,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: ObjectMap) -> Self {
         Value::Object(Rc::new(RefCell::new(map)))
     }
 
@@ -268,7 +273,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(ObjectMap::default())))
     }
 
     /// Extract the number value, if this is a Number.