@tishlang/tish 1.0.29 → 1.0.33

package/crates/tish_bytecode/src/opcode.rs

@@ -80,13 +80,17 @@ pub enum Opcode {
     ArrayFilterBinOp = 35,
     /// Load built-in module export. Operands: u16 spec_const_idx, u16 export_name_const_idx. Pushes Value.
     LoadNativeExport = 36,
+    /// `new callee(...args)` (operand: u16 arg count). Stack: callee, then args — same as Call.
+    Construct = 37,
+    /// `new callee(...spread)` — stack: args array, then callee (same order as CallSpread).
+    ConstructSpread = 38,
 }
 
 impl Opcode {
-    /// Decode byte to opcode. Safe for b in 0..=36 (matches #[repr(u8)] discriminants).
+    /// Decode byte to opcode. Safe for b in 0..=38 (matches #[repr(u8)] discriminants).
     #[inline]
     pub fn from_u8(b: u8) -> Option<Opcode> {
-        if b <= 36 {
+        if b <= 38 {
             Some(unsafe { std::mem::transmute(b) })
         } else {
             None
@@ -97,7 +101,7 @@ impl Opcode {
     pub fn instruction_size(self, code: &[u8], ip: usize) -> Option<usize> {
         let size = match self {
             Opcode::Nop | Opcode::Pop | Opcode::Dup | Opcode::Return | Opcode::ExitTry
-            | Opcode::ArrayMapIdentity => 1,
+            | Opcode::ArrayMapIdentity | Opcode::CallSpread | Opcode::ConstructSpread => 1,
             Opcode::ArraySortByProperty | Opcode::ArrayMapBinOp | Opcode::ArrayFilterBinOp
             | Opcode::LoadNativeExport => 5,
             _ => 3,

package/crates/tish_compile/Cargo.toml

@@ -18,6 +18,7 @@ ws = []
 tishlang_ast = { path = "../tish_ast", 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"] }
 serde_json = "1.0"
 
 [dev-dependencies]

package/crates/tish_compile/src/codegen.rs

@@ -3,7 +3,7 @@
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
-use tishlang_ast::{ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement, UnaryOp};
+use tishlang_ast::{ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr, FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement, UnaryOp};
 use crate::resolve::is_builtin_native_spec;
 use crate::types::{RustType, TypeContext};
 
@@ -120,6 +120,14 @@ impl UsageAnalyzer {
                     }
                 }
             }
+            Expr::New { callee, args, .. } => {
+                self.analyze_expr(callee);
+                for arg in args {
+                    match arg {
+                        CallArg::Expr(e) | CallArg::Spread(e) => self.analyze_expr(e),
+                    }
+                }
+            }
             Expr::Member { object, prop, .. } => {
                 self.analyze_expr(object);
                 if let MemberProp::Expr(e) = prop {
@@ -283,6 +291,11 @@ fn program_uses_async(program: &Program) -> bool {
                     CallArg::Expr(e) | CallArg::Spread(e) => expr_has_await(e),
                 })
             }
+            Expr::New { callee, args, .. } => {
+                expr_has_await(callee) || args.iter().any(|a| match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => expr_has_await(e),
+                })
+            }
             Expr::Member { object, prop, .. } => {
                 expr_has_await(object)
                     || if let MemberProp::Expr(e) = prop {
@@ -468,6 +481,8 @@ struct Codegen {
     usage_analyzer: Option<UsageAnalyzer>,
     /// Type context for tracking variable types (for static typing)
     type_context: TypeContext,
+    /// Program uses JSX; emit `tishlang_ui` imports and `h` / `Fragment` globals.
+    program_has_jsx: bool,
 }
 
 impl Codegen {
@@ -493,6 +508,7 @@ impl Codegen {
             refcell_wrapped_vars: std::collections::HashSet::new(),
             usage_analyzer: None,
             type_context: TypeContext::new(),
+            program_has_jsx: false,
         }
     }
 
@@ -503,7 +519,12 @@ impl Codegen {
             return self.builtin_native_module_rust_init(spec, export_name);
         }
         self.native_module_map.get(spec).map(|(crate_name, export_fn)| {
-            format!("{}::{}()", crate_name, export_fn)
+            // Native modules return a namespace object (like an ES module).
+            // Named imports extract the field from that namespace: `import { foo } from "pkg"` → `ns.foo`.
+            format!(
+                "{{ let _ns = {}::{}(); match _ns {{ Value::Object(ref _o) => _o.borrow().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
+                crate_name, export_fn, export_name
+            )
         })
     }
 
@@ -536,7 +557,7 @@ impl Codegen {
                     "exec" => Some("Value::Function(Rc::new(|args: &[Value]| tish_process_exec(args)))"),
                     "argv" => Some("Value::Array(Rc::new(RefCell::new(std::env::args().map(|s| Value::String(s.into())).collect())))"),
                     "env" => Some("Value::Object(Rc::new(RefCell::new(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect())))"),
-                    "process" => Some("{ let mut m = HashMap::new(); m.insert(Arc::from(\"exit\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exit(args)))); m.insert(Arc::from(\"cwd\"), Value::Function(Rc::new(|args: &[Value]| tish_process_cwd(args)))); m.insert(Arc::from(\"exec\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exec(args)))); m.insert(Arc::from(\"argv\"), Value::Array(Rc::new(RefCell::new(std::env::args().map(|s| Value::String(s.into())).collect())))); m.insert(Arc::from(\"env\"), Value::Object(Rc::new(RefCell::new(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect())))); Value::Object(Rc::new(RefCell::new(m))) }"),
+                    "process" => Some("{ let mut m = ObjectMap::default(); m.insert(Arc::from(\"exit\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exit(args)))); m.insert(Arc::from(\"cwd\"), Value::Function(Rc::new(|args: &[Value]| tish_process_cwd(args)))); m.insert(Arc::from(\"exec\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exec(args)))); m.insert(Arc::from(\"argv\"), Value::Array(Rc::new(RefCell::new(std::env::args().map(|s| Value::String(s.into())).collect())))); m.insert(Arc::from(\"env\"), Value::Object(Rc::new(RefCell::new(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect::<ObjectMap>())))); Value::Object(Rc::new(RefCell::new(m))) }"),
                     _ => None,
                 },
             "tish:ws" if self.has_feature("ws") => match export_name {
@@ -634,6 +655,7 @@ impl Codegen {
                 | Expr::Array { .. }
                 | Expr::Object { .. }
                 | Expr::Call { .. }
+                | Expr::New { .. }
                 | Expr::Await { .. }
                 | Expr::ArrowFunction { .. }
                 | Expr::Binary { .. }
@@ -727,12 +749,17 @@ impl Codegen {
         use tishlang_ast::ArrowBody;
         
         if let Expr::ArrowFunction { params, body, .. } = expr {
-            // Must have exactly 2 params
             if params.len() != 2 {
                 return None;
             }
-            let param_a = params[0].name.as_ref();
-            let param_b = params[1].name.as_ref();
+            let (param_a, param_b) = match (&params[0], &params[1]) {
+                (FunParam::Simple(a), FunParam::Simple(b))
+                    if a.default.is_none() && b.default.is_none() =>
+                {
+                    (a.name.as_ref(), b.name.as_ref())
+                }
+                _ => return None,
+            };
             
             // Body must be a single expression that's a subtraction
             let body_expr = match body {
@@ -763,12 +790,15 @@ impl Codegen {
 
     fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
         self.is_async = program_uses_async(program);
+        self.program_has_jsx = tishlang_ui::jsx::program_contains_jsx(program);
         self.write("#![allow(unused, non_snake_case)]\n\n");
         self.write("use std::cell::RefCell;\n");
-        self.write("use std::collections::HashMap;\n");
         self.write("use std::rc::Rc;\n");
         self.write("use std::sync::Arc;\n");
-        self.write("use tishlang_runtime::{console_debug as tish_console_debug, console_info as tish_console_info, console_log as tish_console_log, console_warn as tish_console_warn, console_error as tish_console_error, boolean as tish_boolean, decode_uri as tish_decode_uri, encode_uri as tish_encode_uri, in_operator as tish_in_operator, is_finite as tish_is_finite, is_nan as tish_is_nan, json_parse as tish_json_parse, json_stringify as tish_json_stringify, math_abs as tish_math_abs, math_ceil as tish_math_ceil, math_floor as tish_math_floor, math_max as tish_math_max, math_min as tish_math_min, math_round as tish_math_round, math_sqrt as tish_math_sqrt, parse_float as tish_parse_float, parse_int as tish_parse_int, math_random as tish_math_random, math_pow as tish_math_pow, math_sin as tish_math_sin, math_cos as tish_math_cos, math_tan as tish_math_tan, math_log as tish_math_log, math_exp as tish_math_exp, math_sign as tish_math_sign, math_trunc as tish_math_trunc, date_now as tish_date_now, array_is_array as tish_array_is_array, string_from_char_code as tish_string_from_char_code, object_assign as tish_object_assign, object_keys as tish_object_keys, object_values as tish_object_values, object_entries as tish_object_entries, object_from_entries as tish_object_from_entries, TishError, Value};\n");
+        self.write("use tishlang_runtime::{console_debug as tish_console_debug, console_info as tish_console_info, console_log as tish_console_log, console_warn as tish_console_warn, console_error as tish_console_error, boolean as tish_boolean, decode_uri as tish_decode_uri, encode_uri as tish_encode_uri, in_operator as tish_in_operator, is_finite as tish_is_finite, is_nan as tish_is_nan, json_parse as tish_json_parse, json_stringify as tish_json_stringify, math_abs as tish_math_abs, math_ceil as tish_math_ceil, math_floor as tish_math_floor, math_max as tish_math_max, math_min as tish_math_min, math_round as tish_math_round, math_sqrt as tish_math_sqrt, parse_float as tish_parse_float, parse_int as tish_parse_int, math_random as tish_math_random, math_pow as tish_math_pow, math_sin as tish_math_sin, math_cos as tish_math_cos, math_tan as tish_math_tan, math_log as tish_math_log, math_exp as tish_math_exp, math_sign as tish_math_sign, math_trunc as tish_math_trunc, date_now as tish_date_now, array_is_array as tish_array_is_array, string_from_char_code as tish_string_from_char_code, object_assign as tish_object_assign, object_keys as tish_object_keys, object_values as tish_object_values, object_entries as tish_object_entries, object_from_entries as tish_object_from_entries, tish_construct, tish_uint8_array_constructor, tish_audio_context_constructor, ObjectMap, TishError, Value};\n");
+        if self.program_has_jsx {
+            self.write("use tishlang_ui::{fragment_value, install_thread_local_host, native_create_root, native_use_state, ui_h, ui_text, HeadlessHost};\n");
+        }
         if self.has_feature("process") {
             self.write("use tishlang_runtime::{process_exit as tish_process_exit, process_cwd as tish_process_cwd, process_exec as tish_process_exec};\n");
         }
@@ -818,7 +848,7 @@ impl Codegen {
         self.indent += 1;
 
         // Initialize builtins
-        self.writeln("let mut console = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let mut console = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"debug\"), Value::Function(Rc::new(|args: &[Value]| { tish_console_debug(args); Value::Null }))),");
         self.writeln("(Arc::from(\"info\"), Value::Function(Rc::new(|args: &[Value]| { tish_console_info(args); Value::Null }))),");
@@ -836,7 +866,7 @@ impl Codegen {
         self.writeln("let isNaN = Value::Function(Rc::new(|args: &[Value]| tish_is_nan(args)));");
         self.writeln("let Infinity = Value::Number(f64::INFINITY);");
         self.writeln("let NaN = Value::Number(f64::NAN);");
-        self.writeln("let Math = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let Math = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"abs\"), Value::Function(Rc::new(|args: &[Value]| tish_math_abs(args)))),");
         self.writeln("(Arc::from(\"sqrt\"), Value::Function(Rc::new(|args: &[Value]| tish_math_sqrt(args)))),");
@@ -858,32 +888,32 @@ impl Codegen {
         self.writeln("(Arc::from(\"E\"), Value::Number(std::f64::consts::E)),");
         self.indent -= 1;
         self.writeln("]))));");
-        self.writeln("let JSON = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let JSON = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"parse\"), Value::Function(Rc::new(|args: &[Value]| tish_json_parse(args)))),");
         self.writeln("(Arc::from(\"stringify\"), Value::Function(Rc::new(|args: &[Value]| tish_json_stringify(args)))),");
         self.indent -= 1;
         self.writeln("]))));");
 
-        self.writeln("let Array = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let Array = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"isArray\"), Value::Function(Rc::new(|args: &[Value]| tish_array_is_array(args)))),");
         self.indent -= 1;
         self.writeln("]))));");
 
-        self.writeln("let String = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let String = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"fromCharCode\"), Value::Function(Rc::new(|args: &[Value]| tish_string_from_char_code(args)))),");
         self.indent -= 1;
         self.writeln("]))));");
 
-        self.writeln("let Date = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let Date = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"now\"), Value::Function(Rc::new(|args: &[Value]| tish_date_now(args)))),");
         self.indent -= 1;
         self.writeln("]))));");
 
-        self.writeln("let Object = Value::Object(Rc::new(RefCell::new(HashMap::from([");
+        self.writeln("let Object = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"assign\"), Value::Function(Rc::new(|args: &[Value]| tish_object_assign(args)))),");
         self.writeln("(Arc::from(\"keys\"), Value::Function(Rc::new(|args: &[Value]| tish_object_keys(args)))),");
@@ -893,16 +923,19 @@ impl Codegen {
         self.indent -= 1;
         self.writeln("]))));");
 
+        self.writeln("let Uint8Array = tish_uint8_array_constructor();");
+        self.writeln("let AudioContext = tish_audio_context_constructor();");
+
         if self.has_feature("process") {
             self.writeln("let process = Value::Object(Rc::new(RefCell::new({");
             self.indent += 1;
-            self.writeln("let mut p = HashMap::new();");
+            self.writeln("let mut p = ObjectMap::default();");
             self.writeln("p.insert(Arc::from(\"exit\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exit(args))));");
             self.writeln("p.insert(Arc::from(\"cwd\"), Value::Function(Rc::new(|args: &[Value]| tish_process_cwd(args))));");
             self.writeln("p.insert(Arc::from(\"exec\"), Value::Function(Rc::new(|args: &[Value]| tish_process_exec(args))));");
             self.writeln("let argv: Vec<Value> = std::env::args().map(|s| Value::String(s.into())).collect();");
             self.writeln("p.insert(Arc::from(\"argv\"), Value::Array(Rc::new(RefCell::new(argv))));");
-            self.writeln("let mut env_obj = HashMap::new();");
+            self.writeln("let mut env_obj = ObjectMap::default();");
             self.writeln("for (key, value) in std::env::vars() {");
             self.indent += 1;
             self.writeln("env_obj.insert(Arc::from(key.as_str()), Value::String(value.into()));");
@@ -952,6 +985,15 @@ impl Codegen {
             self.writeln("let RegExp = Value::Function(Rc::new(|args: &[Value]| regexp_new(args)));");
         }
 
+        if self.program_has_jsx {
+            self.writeln("install_thread_local_host(Box::new(HeadlessHost::default()));");
+            self.writeln("let Fragment = fragment_value();");
+            self.writeln("let h = Value::Function(Rc::new(|args: &[Value]| ui_h(args)));");
+            self.writeln("let text = Value::Function(Rc::new(|args: &[Value]| ui_text(args)));");
+            self.writeln("let useState = Value::Function(Rc::new(|args: &[Value]| native_use_state(args)));");
+            self.writeln("let createRoot = Value::Function(Rc::new(|args: &[Value]| native_create_root(args)));");
+        }
+
         // Polars, Egui etc. are emitted via VarDecl from import { X } from 'tish:...'
 
         // Pre-scan for top-level function declarations and create cells (for mutual recursion)
@@ -1078,11 +1120,8 @@ impl Codegen {
                 let expr = self.emit_expr(init)?;
                 let mutability = if *mutable { "let mut" } else { "let" };
                 let clone_suffix = if Self::needs_clone(init) { ".clone()" } else { "" };
-                self.writeln(&format!("{{ let _destruct_val = ({}){};", expr, clone_suffix));
-                self.indent += 1;
+                self.writeln(&format!("let _destruct_val = ({}){};", expr, clone_suffix));
                 self.emit_destruct_bindings(pattern, "_destruct_val", mutability, *span)?;
-                self.indent -= 1;
-                self.writeln("}");
             }
             Statement::ExprStmt { expr, .. } => {
                 let e = self.emit_expr(expr)?;
@@ -1326,7 +1365,7 @@ impl Codegen {
                     self.emit_statement(finally_stmt)?;
                 }
             }
-            Statement::FunDecl { name, params, rest_param, body, .. } => {
+            Statement::FunDecl { name, params, rest_param, body, span, .. } => {
                 // Use Rc<RefCell<>> pattern to allow recursive function calls
                 // The function can reference itself through the cell
                 let name_raw = name.as_ref();
@@ -1343,7 +1382,11 @@ impl Codegen {
                 // Analyze body to find which identifiers are actually referenced
                 let mut referenced = HashSet::new();
                 Self::collect_stmt_idents(body, &mut referenced);
-                let param_names: HashSet<String> = params.iter().map(|p| p.name.to_string()).collect();
+                let param_names: HashSet<String> = params
+                    .iter()
+                    .flat_map(|p| p.bound_names())
+                    .map(|n| n.to_string())
+                    .collect();
                 
                 // Collect all outer parameters that need to be captured (only those referenced)
                 let outer_params: Vec<String> = self.outer_params_stack
@@ -1418,7 +1461,7 @@ impl Codegen {
                     self.writeln(&format!("let {} = {}.clone();", param_escaped, param_escaped));
                 }
                 // Only clone builtins that are actually referenced (clone so outer scope can still use them, e.g. process for PORT before serve)
-                for builtin in &["Boolean", "console", "Math", "JSON", "Date", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
+                for builtin in &["Boolean", "console", "Math", "JSON", "Date", "Uint8Array", "AudioContext", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
                     if referenced.contains(*builtin) {
                         self.writeln(&format!("let {} = {}.clone();", builtin, builtin));
                     }
@@ -1445,13 +1488,30 @@ impl Codegen {
                     self.writeln(&format!("let {} = (*{}_ref.borrow()).clone();", sibling_escaped, sibling_escaped));
                 }
                 // Extract just the parameter names (type annotations are parsed but not used in codegen yet)
-                let current_param_names: Vec<String> = params.iter().map(|p| p.name.to_string()).collect();
+                let current_param_names: Vec<String> = params
+                    .iter()
+                    .flat_map(|p| p.bound_names())
+                    .map(|n| n.to_string())
+                    .collect();
+                let formal_span = *span;
                 for (i, p) in params.iter().enumerate() {
-                    self.writeln(&format!(
-                        "let mut {} = args.get({}).cloned().unwrap_or(Value::Null);",
-                        Self::escape_ident(p.name.as_ref()),
-                        i
-                    ));
+                    match p {
+                        FunParam::Simple(tp) => {
+                            self.writeln(&format!(
+                                "let mut {} = args.get({}).cloned().unwrap_or(Value::Null);",
+                                Self::escape_ident(tp.name.as_ref()),
+                                i
+                            ));
+                        }
+                        FunParam::Destructure { pattern, .. } => {
+                            let tmp = format!("_formal_{}", i);
+                            self.writeln(&format!(
+                                "let {} = args.get({}).cloned().unwrap_or(Value::Null);",
+                                tmp, i
+                            ));
+                            self.emit_destruct_bindings(pattern, &tmp, "let mut", formal_span)?;
+                        }
+                    }
                 }
                 if let Some(rest) = rest_param {
                     self.writeln(&format!(
@@ -1562,58 +1622,71 @@ impl Codegen {
     }
 
     fn emit_destruct_bindings(&mut self, pattern: &DestructPattern, value_expr: &str, mutability: &str, span: Span) -> Result<(), CompileError> {
+        // Flat `let` bindings so names stay in scope for the rest of the function (e.g. JSX).
         match pattern {
             DestructPattern::Array(elements) => {
-                self.writeln(&format!("if let Value::Array(ref _arr) = {} {{", value_expr));
-                self.indent += 1;
-                self.writeln("let _arr_borrow = _arr.borrow();");
                 for (i, elem) in elements.iter().enumerate() {
                     if let Some(el) = elem {
                         match el {
                             DestructElement::Ident(name) => {
-                                self.writeln(&format!("{} {} = _arr_borrow.get({}).cloned().unwrap_or(Value::Null);", 
-                                    mutability, Self::escape_ident(name.as_ref()), i));
+                                self.writeln(&format!(
+                                    "{} {} = match &({}) {{ Value::Array(ref _a) => _a.borrow().get({}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
+                                    mutability,
+                                    Self::escape_ident(name.as_ref()),
+                                    value_expr,
+                                    i
+                                ));
                             }
                             DestructElement::Pattern(nested) => {
-                                let nested_var = format!("_nested_{}", i);
-                                self.writeln(&format!("let {} = _arr_borrow.get({}).cloned().unwrap_or(Value::Null);", 
-                                    nested_var, i));
+                                let nested_var = format!("_nested_arr_{}", i);
+                                self.writeln(&format!(
+                                    "let {} = match &({}) {{ Value::Array(ref _a) => _a.borrow().get({}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
+                                    nested_var, value_expr, i
+                                ));
                                 self.emit_destruct_bindings(nested, &nested_var, mutability, span)?;
                             }
                             DestructElement::Rest(name) => {
-                                self.writeln(&format!("{} {} = Value::Array(Rc::new(RefCell::new(_arr_borrow.iter().skip({}).cloned().collect())));", 
-                                    mutability, Self::escape_ident(name.as_ref()), i));
+                                self.writeln(&format!(
+                                    "{} {} = match &({}) {{ Value::Array(ref _a) => {{ let _b = _a.borrow(); Value::Array(Rc::new(RefCell::new(_b.iter().skip({}).cloned().collect()))) }}, _ => Value::Array(Rc::new(RefCell::new(Vec::new()))) }};",
+                                    mutability,
+                                    Self::escape_ident(name.as_ref()),
+                                    value_expr,
+                                    i
+                                ));
                             }
                         }
                     }
                 }
-                self.indent -= 1;
-                self.writeln("}");
             }
             DestructPattern::Object(props) => {
-                self.writeln(&format!("if let Value::Object(ref _obj) = {} {{", value_expr));
-                self.indent += 1;
-                self.writeln("let _obj_borrow = _obj.borrow();");
                 for prop in props {
                     let key = prop.key.as_ref();
                     match &prop.value {
                         DestructElement::Ident(name) => {
-                            self.writeln(&format!("{} {} = _obj_borrow.get({:?}).cloned().unwrap_or(Value::Null);", 
-                                mutability, Self::escape_ident(name.as_ref()), key));
+                            self.writeln(&format!(
+                                "{} {} = match &({}) {{ Value::Object(ref _o) => _o.borrow().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
+                                mutability,
+                                Self::escape_ident(name.as_ref()),
+                                value_expr,
+                                key
+                            ));
                         }
                         DestructElement::Pattern(nested) => {
-                            let nested_var = format!("_nested_{}", key);
-                            self.writeln(&format!("let {} = _obj_borrow.get({:?}).cloned().unwrap_or(Value::Null);", 
-                                nested_var, key));
+                            let nested_var = format!("_nested_obj_{}", key);
+                            self.writeln(&format!(
+                                "let {} = match &({}) {{ Value::Object(ref _o) => _o.borrow().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
+                                nested_var, value_expr, key
+                            ));
                             self.emit_destruct_bindings(nested, &nested_var, mutability, span)?;
                         }
                         DestructElement::Rest(_) => {
-                            return Err(CompileError::new("Rest in object destructuring not supported", Some(span)));
+                            return Err(CompileError::new(
+                                "Rest in object destructuring not supported",
+                                Some(span),
+                            ));
                         }
                     }
                 }
-                self.indent -= 1;
-                self.writeln("}");
             }
         }
         Ok(())
@@ -2164,7 +2237,7 @@ impl Codegen {
                             }
                         }
                     }
-                    format!("{{ let mut _obj: HashMap<Arc<str>, Value> = HashMap::new(); {} Value::Object(Rc::new(RefCell::new(_obj))) }}", parts.join(" "))
+                    format!("{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(Rc::new(RefCell::new(_obj))) }}", parts.join(" "))
                 } else {
                     let mut parts = Vec::new();
                     for prop in props {
@@ -2178,7 +2251,7 @@ impl Codegen {
                         }
                     }
                     format!(
-                        "Value::Object(Rc::new(RefCell::new(HashMap::from([{}]))))",
+                        "Value::Object(Rc::new(RefCell::new(ObjectMap::from([{}]))))",
                         parts.join(", ")
                     )
                 }
@@ -2338,8 +2411,8 @@ impl Codegen {
                     val
                 )
             }
-            Expr::ArrowFunction { params, body, .. } => {
-                self.emit_arrow_function(params, body)?
+            Expr::ArrowFunction { params, body, span, .. } => {
+                self.emit_arrow_function(params, body, *span)?
             }
             Expr::TemplateLiteral { quasis, exprs, .. } => {
                 // Build the template string
@@ -2356,7 +2429,33 @@ impl Codegen {
                 format!("Value::String([{}].concat().into())", parts.join(", "))
             }
             Expr::JsxElement { .. } | Expr::JsxFragment { .. } => {
-                return Err(CompileError { message: "JSX is only supported when compiling to JavaScript (tish compile --target js).".to_string(), span: None });
+                tishlang_ui::jsx::emit_jsx_rust(expr, &mut |e| {
+                    self.emit_expr(e).map_err(|ce| ce.message)
+                })
+                .map_err(|m| CompileError::new(m, None))?
+            }
+            Expr::New { callee, args, .. } => {
+                let callee_expr = self.emit_expr(callee)?;
+                let has_spread = args.iter().any(|a| matches!(a, CallArg::Spread(_)));
+                if has_spread {
+                    let args_code = self.emit_call_args(args)?;
+                    return Ok(format!(
+                        "{{ let _callee = ({}).clone(); let _spread_args = {}; tish_construct(&_callee, &_spread_args[..]) }}",
+                        callee_expr, args_code
+                    ));
+                }
+                let arg_exprs: Result<Vec<_>, _> =
+                    args.iter().map(|a| self.emit_call_arg(a)).collect();
+                let arg_exprs = arg_exprs?;
+                let args_vec = arg_exprs
+                    .iter()
+                    .map(|a| format!("{}.clone()", a))
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!(
+                    "tish_construct(&({}).clone(), &[{}])",
+                    callee_expr, args_vec
+                )
             }
             Expr::NativeModuleLoad { spec, export_name, .. } => {
                 self.native_module_rust_init(spec.as_ref(), export_name.as_ref())
@@ -2410,6 +2509,14 @@ impl Codegen {
                     }
                 }
             }
+            Expr::New { callee, args, .. } => {
+                Self::collect_expr_idents(callee, idents);
+                for arg in args {
+                    match arg {
+                        CallArg::Expr(e) | CallArg::Spread(e) => Self::collect_expr_idents(e, idents),
+                    }
+                }
+            }
             Expr::Member { object, prop, .. } => {
                 Self::collect_expr_idents(object, idents);
                 if let MemberProp::Expr(e) = prop { Self::collect_expr_idents(e, idents); }
@@ -2613,6 +2720,16 @@ impl Codegen {
                     }
                 }
             }
+            Expr::New { callee, args, .. } => {
+                Self::collect_assigned_idents_in_expr(callee, names);
+                for arg in args {
+                    match arg {
+                        CallArg::Expr(e) | CallArg::Spread(e) => {
+                            Self::collect_assigned_idents_in_expr(e, names);
+                        }
+                    }
+                }
+            }
             Expr::Member { object, prop, .. } => {
                 Self::collect_assigned_idents_in_expr(object, names);
                 if let MemberProp::Expr(e) = prop {
@@ -2725,12 +2842,16 @@ impl Codegen {
     /// Collect variable names that are both captured and mutated by a closure body.
     /// block_vars: vars declared in the enclosing block (candidates for mutation).
     fn collect_mutated_captures_from_closure(
-        params: &[tishlang_ast::TypedParam],
+        params: &[FunParam],
         body: &Statement,
         block_vars: &HashSet<String>,
         result: &mut HashSet<String>,
     ) {
-        let param_names: HashSet<String> = params.iter().map(|p| p.name.to_string()).collect();
+        let param_names: HashSet<String> = params
+            .iter()
+            .flat_map(|p| p.bound_names())
+            .map(|n| n.to_string())
+            .collect();
         let mut local_var_names = HashSet::new();
         Self::collect_local_var_names(body, &mut local_var_names);
         let mut referenced = HashSet::new();
@@ -2754,12 +2875,16 @@ impl Codegen {
     }
 
     fn collect_mutated_captures_from_arrow(
-        params: &[tishlang_ast::TypedParam],
+        params: &[FunParam],
         body: &ArrowBody,
         block_vars: &HashSet<String>,
         result: &mut HashSet<String>,
     ) {
-        let param_names: HashSet<String> = params.iter().map(|p| p.name.to_string()).collect();
+        let param_names: HashSet<String> = params
+            .iter()
+            .flat_map(|p| p.bound_names())
+            .map(|n| n.to_string())
+            .collect();
         let mut local_var_names = HashSet::new();
         match body {
             ArrowBody::Expr(_) => {}
@@ -2808,6 +2933,16 @@ impl Codegen {
                     }
                 }
             }
+            Expr::New { callee, args, .. } => {
+                Self::collect_mutated_captures_from_expr(callee, block_vars, result);
+                for arg in args {
+                    match arg {
+                        CallArg::Expr(e) | CallArg::Spread(e) => {
+                            Self::collect_mutated_captures_from_expr(e, block_vars, result);
+                        }
+                    }
+                }
+            }
             Expr::Member { object, prop, .. } => {
                 Self::collect_mutated_captures_from_expr(object, block_vars, result);
                 if let MemberProp::Expr(e) = prop {
@@ -3055,8 +3190,9 @@ impl Codegen {
 
     fn emit_arrow_function(
         &mut self,
-        params: &[tishlang_ast::TypedParam],
+        params: &[FunParam],
         body: &tishlang_ast::ArrowBody,
+        span: Span,
     ) -> Result<String, CompileError> {
         // Build the arrow function as a Value::Function closure
         let mut code = String::new();
@@ -3065,7 +3201,11 @@ impl Codegen {
         // Find which identifiers are actually referenced in the body
         let referenced = Self::collect_referenced_idents(body);
         // Exclude the arrow's own parameters - they're not outer captures
-        let param_names: HashSet<String> = params.iter().map(|p| p.name.to_string()).collect();
+        let param_names: HashSet<String> = params
+            .iter()
+            .flat_map(|p| p.bound_names())
+            .map(|n| n.to_string())
+            .collect();
 
         // Exclude variables declared inside the arrow body (locals)
         let mut local_var_names = HashSet::new();
@@ -3120,7 +3260,7 @@ impl Codegen {
             }
         }
         // Only clone builtins that are actually referenced (clone so outer scope can still use, e.g. process for PORT)
-        for builtin in &["console", "Math", "JSON", "Date", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
+        for builtin in &["console", "Math", "JSON", "Date", "Uint8Array", "AudioContext", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
             if referenced.contains(*builtin) {
                 code.push_str(&format!("    let {} = {}.clone();\n", builtin, builtin));
             }
@@ -3164,13 +3304,35 @@ impl Codegen {
         }
 
         // Extract parameters from args
-        let current_param_names: Vec<String> = params.iter().map(|p| p.name.to_string()).collect();
+        let current_param_names: Vec<String> = params
+            .iter()
+            .flat_map(|p| p.bound_names())
+            .map(|n| n.to_string())
+            .collect();
         for (i, p) in params.iter().enumerate() {
-            code.push_str(&format!(
-                "        let mut {} = args.get({}).cloned().unwrap_or(Value::Null);\n",
-                Self::escape_ident(p.name.as_ref()),
-                i
-            ));
+            match p {
+                FunParam::Simple(tp) => {
+                    code.push_str(&format!(
+                        "        let mut {} = args.get({}).cloned().unwrap_or(Value::Null);\n",
+                        Self::escape_ident(tp.name.as_ref()),
+                        i
+                    ));
+                }
+                FunParam::Destructure { pattern, .. } => {
+                    let tmp = format!("_formal_{}", i);
+                    code.push_str(&format!(
+                        "        let {} = args.get({}).cloned().unwrap_or(Value::Null);\n",
+                        tmp, i
+                    ));
+                    let saved = std::mem::take(&mut self.output);
+                    let saved_indent = self.indent;
+                    self.indent = 8;
+                    self.emit_destruct_bindings(pattern, &tmp, "let mut", span)?;
+                    let frag = std::mem::replace(&mut self.output, saved);
+                    self.indent = saved_indent;
+                    code.push_str(&frag);
+                }
+            }
         }
 
         // Push current params for potential nested arrows