@tishlang/tish 1.0.29 → 1.0.34

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 {
@@ -430,6 +443,9 @@ pub fn compile_with_native_modules(
     optimize: bool,
 ) -> Result<String, CompileError> {
     let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
+    // Type-inference pass: fills in `type_ann` on unannotated VarDecl nodes where
+    // the type is unambiguous (literals, arithmetic of typed vars, etc.).
+    let program = crate::infer::infer_program(&program);
     let map: std::collections::HashMap<String, (String, String)> = native_modules
         .iter()
         .map(|m| (m.spec.clone(), (m.crate_name.clone(), m.export_fn.clone())))
@@ -468,6 +484,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 +511,7 @@ impl Codegen {
             refcell_wrapped_vars: std::collections::HashSet::new(),
             usage_analyzer: None,
             type_context: TypeContext::new(),
+            program_has_jsx: false,
         }
     }
 
@@ -503,7 +522,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 +560,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 +658,7 @@ impl Codegen {
                 | Expr::Array { .. }
                 | Expr::Object { .. }
                 | Expr::Call { .. }
+                | Expr::New { .. }
                 | Expr::Await { .. }
                 | Expr::ArrowFunction { .. }
                 | Expr::Binary { .. }
@@ -684,7 +709,18 @@ impl Codegen {
     fn emit_inc_dec(&self, name: &str, is_prefix: bool, delta: &str, op_name: &str) -> String {
         let n = Self::escape_ident(name);
         let is_wrapped = self.refcell_wrapped_vars.contains(name);
-        
+        let var_type = self.type_context.get_type(name);
+
+        // Native fast path: f64 variable → avoid boxing/unboxing.
+        if !is_wrapped && var_type == RustType::F64 {
+            let op_assign = if delta.contains('+') { "+=" } else { "-=" };
+            return if is_prefix {
+                format!("{{ {n} {op_assign} 1.0_f64; Value::Number({n}) }}")
+            } else {
+                format!("{{ let _prev = {n}; {n} {op_assign} 1.0_f64; Value::Number(_prev) }}")
+            };
+        }
+
         if is_prefix {
             if is_wrapped {
                 format!(
@@ -695,16 +731,14 @@ impl Codegen {
                     "{{ {n} = Value::Number(match &{n} {{ Value::Number(n) => n {delta}, _ => panic!(\"{op_name} needs number\") }}); {n}.clone() }}"
                 )
             }
+        } else if is_wrapped {
+            format!(
+                "{{ let _v = (*{n}.borrow()).clone(); *{n}.borrow_mut() = Value::Number(match &_v {{ Value::Number(n) => n {delta}, _ => panic!(\"{op_name} needs number\") }}); _v }}"
+            )
         } else {
-            if is_wrapped {
-                format!(
-                    "{{ let _v = (*{n}.borrow()).clone(); *{n}.borrow_mut() = Value::Number(match &_v {{ Value::Number(n) => n {delta}, _ => panic!(\"{op_name} needs number\") }}); _v }}"
-                )
-            } else {
-                format!(
-                    "{{ let _v = {n}.clone(); {n} = Value::Number(match &_v {{ Value::Number(n) => n {delta}, _ => panic!(\"{op_name} needs number\") }}); _v }}"
-                )
-            }
+            format!(
+                "{{ let _v = {n}.clone(); {n} = Value::Number(match &_v {{ Value::Number(n) => n {delta}, _ => panic!(\"{op_name} needs number\") }}); _v }}"
+            )
         }
     }
 
@@ -727,12 +761,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 +802,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 +860,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 +878,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 +900,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 +935,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 +997,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 +1132,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)?;
@@ -1094,8 +1145,8 @@ impl Codegen {
                 else_branch,
                 ..
             } => {
-                let c = self.emit_expr(cond)?;
-                self.write(&format!("if {}.is_truthy() {{\n", c));
+                let c = self.emit_cond_expr(cond)?;
+                self.write(&format!("if {} {{\n", c));
                 self.indent += 1;
                 self.emit_statement(then_branch)?;
                 self.indent -= 1;
@@ -1108,11 +1159,11 @@ impl Codegen {
                 self.writeln("}");
             }
             Statement::While { cond, body, .. } => {
-                let c = self.emit_expr(cond)?;
+                let c = self.emit_cond_expr(cond)?;
                 let label = format!("'while_loop_{}", self.loop_label_index);
                 self.loop_label_index += 1;
                 self.loop_stack.push((label.clone(), None));
-                self.write(&format!("{}: while {}.is_truthy() {{\n", label, c));
+                self.write(&format!("{}: while {} {{\n", label, c));
                 self.indent += 1;
                 self.emit_statement(body)?;
                 self.loop_stack.pop();
@@ -1170,7 +1221,7 @@ impl Codegen {
                 self.loop_label_index += 1;
                 let cond_expr = cond
                     .as_ref()
-                    .map(|c| format!("{}.is_truthy()", self.emit_expr(c).unwrap()))
+                    .map(|c| self.emit_cond_expr(c).unwrap())
                     .unwrap_or_else(|| "true".to_string());
                 let update_code = update.as_ref().map(|u| {
                     let ue = self.emit_expr(u).unwrap();
@@ -1262,14 +1313,14 @@ impl Codegen {
                 self.writeln("}");
             }
             Statement::DoWhile { body, cond, .. } => {
-                let c = self.emit_expr(cond)?;
+                let c = self.emit_cond_expr(cond)?;
                 let label = format!("'dowhile_loop_{}", self.loop_label_index);
                 self.loop_label_index += 1;
                 self.loop_stack.push((label.clone(), None));
                 self.write(&format!("{}: loop {{\n", label));
                 self.indent += 1;
                 self.emit_statement(body)?;
-                self.write(&format!("if !{}.is_truthy() {{ break; }}\n", c));
+                self.write(&format!("if !{} {{ break; }}\n", c));
                 self.loop_stack.pop();
                 self.indent -= 1;
                 self.writeln("}");
@@ -1326,7 +1377,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 +1394,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 +1473,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 +1500,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 +1634,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(())
@@ -1642,10 +1727,10 @@ impl Codegen {
                     }
                 }
             }
-            Expr::Binary { left, op, right, span, .. } => {
-                let l = self.emit_expr(left)?;
-                let r = self.emit_expr(right)?;
-                self.emit_binop(&l, *op, &r, *span)?
+            Expr::Binary { .. } => {
+                // Delegate to emit_typed_expr; wrap the native result in Value.
+                let (code, ty) = self.emit_typed_expr(expr)?;
+                if ty.is_native() { ty.to_value_expr(&code) } else { code }
             }
             Expr::Unary { op, operand, .. } => {
                 let o = self.emit_expr(operand)?;
@@ -1706,6 +1791,37 @@ impl Codegen {
 
                 // Check for built-in method calls on arrays/strings
                 if let Expr::Member { object, prop: MemberProp::Name(method_name), .. } = callee.as_ref() {
+                    // ── native Vec<T> push fast path ──────────────────────────────
+                    if method_name.as_ref() == "push" {
+                        if let Expr::Ident { name, .. } = object.as_ref() {
+                            if !self.refcell_wrapped_vars.contains(name.as_ref()) {
+                                let obj_type = self.type_context.get_type(name.as_ref());
+                                if let RustType::Vec(elem_type) = obj_type {
+                                    let esc_obj = Self::escape_ident(name.as_ref()).into_owned();
+                                    // Collect push arguments as native values.
+                                    let mut push_stmts: Vec<String> = Vec::new();
+                                    for a in args {
+                                        if let CallArg::Expr(e) = a {
+                                            let (val_code, val_ty) = self.emit_typed_expr(e)?;
+                                            let native_val = if val_ty == *elem_type {
+                                                val_code
+                                            } else if val_ty == RustType::Value {
+                                                elem_type.from_value_expr(&val_code)
+                                            } else {
+                                                val_code
+                                            };
+                                            push_stmts.push(format!("{}.push({});", esc_obj, native_val));
+                                        }
+                                    }
+                                    return Ok(format!(
+                                        "{{ {} Value::Null }}",
+                                        push_stmts.join(" ")
+                                    ));
+                                }
+                            }
+                        }
+                    }
+
                     let obj_expr = self.emit_expr(object)?;
                     let arg_exprs: Result<Vec<_>, _> =
                         args.iter().map(|a| self.emit_call_arg(a)).collect();
@@ -2063,23 +2179,24 @@ impl Codegen {
                     format!("tishlang_runtime::get_prop(&{}, {})", obj, key)
                 }
             }
+            Expr::Index { optional, .. } if !optional => {
+                // Try native Vec<T> fast path via emit_typed_expr; wrap result.
+                let (code, ty) = self.emit_typed_expr(expr)?;
+                if ty.is_native() { ty.to_value_expr(&code) } else { code }
+            }
             Expr::Index {
                 object,
                 index,
-                optional,
                 ..
             } => {
+                // optional chaining: always use runtime path
                 let obj = self.emit_expr(object)?;
                 let idx = self.emit_expr(index)?;
-                if *optional {
-                    format!(
-                        "{{ let o = {}.clone(); if matches!(o, Value::Null) {{ Value::Null }} else {{ \
-                         tishlang_runtime::get_index(&o, &{}) }} }}",
-                        obj, idx
-                    )
-                } else {
-                    format!("tishlang_runtime::get_index(&{}, &{})", obj, idx)
-                }
+                format!(
+                    "{{ let o = {}.clone(); if matches!(o, Value::Null) {{ Value::Null }} else {{ \
+                     tishlang_runtime::get_index(&o, &{}) }} }}",
+                    obj, idx
+                )
             }
             Expr::Conditional {
                 cond,
@@ -2164,7 +2281,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,14 +2295,35 @@ impl Codegen {
                         }
                     }
                     format!(
-                        "Value::Object(Rc::new(RefCell::new(HashMap::from([{}]))))",
+                        "Value::Object(Rc::new(RefCell::new(ObjectMap::from([{}]))))",
                         parts.join(", ")
                     )
                 }
             }
             Expr::Assign { name, value, .. } => {
-                let val = self.emit_expr(value)?;
                 let escaped = Self::escape_ident(name.as_ref());
+                // Native fast path: if the target is a scalar native type, emit
+                // a direct assignment without boxing/unboxing through Value.
+                if !self.refcell_wrapped_vars.contains(name.as_ref()) {
+                    let rust_type = self.type_context.get_type(name.as_ref());
+                    if rust_type.is_native() && matches!(rust_type, RustType::F64 | RustType::Bool | RustType::String) {
+                        let (val_code, val_ty) = self.emit_typed_expr(value)?;
+                        let native_val = if val_ty == rust_type {
+                            val_code
+                        } else if val_ty == RustType::Value {
+                            rust_type.from_value_expr(&val_code)
+                        } else {
+                            val_code
+                        };
+                        let return_val = rust_type.to_value_expr(&escaped);
+                        return Ok(format!(
+                            "{{ {} = {}; {} }}",
+                            escaped, native_val, return_val
+                        ));
+                    }
+                }
+                // Fallback: Value path
+                let val = self.emit_expr(value)?;
                 let needs_outer_clone = self.should_clone(value);
                 if self.refcell_wrapped_vars.contains(name.as_ref()) {
                     if needs_outer_clone {
@@ -2194,7 +2332,6 @@ impl Codegen {
                         format!("{{ let _v = {}; *{}.borrow_mut() = _v.clone(); _v }}", val, escaped)
                     }
                 } else {
-                    // Use type_context: typed vars need from_value_expr; Value needs .clone() (we return _v)
                     let rust_type = self.type_context.get_type(name.as_ref());
                     let assign_rhs = if matches!(rust_type, RustType::Value) {
                         "_v.clone()".to_string()
@@ -2253,8 +2390,65 @@ impl Codegen {
             Expr::PrefixInc { name, .. } => self.emit_inc_dec(name.as_ref(), true, "+ 1.0", "++"),
             Expr::PrefixDec { name, .. } => self.emit_inc_dec(name.as_ref(), true, "- 1.0", "--"),
             Expr::CompoundAssign { name, op, value, .. } => {
-                let val = self.emit_expr(value)?;
                 let n = Self::escape_ident(name.as_ref());
+                let is_refcell = self.refcell_wrapped_vars.contains(name.as_ref());
+                let var_type = self.type_context.get_type(name.as_ref());
+
+                // ── native f64 fast path: direct arithmetic operators ─────────
+                // emit_expr must return a Value expression; wrap the result back.
+                if !is_refcell && var_type == RustType::F64 {
+                    let (rhs_code, rhs_ty) = self.emit_typed_expr(value)?;
+                    let rhs_f64 = if rhs_ty == RustType::F64 {
+                        rhs_code
+                    } else {
+                        // rhs is Value or another native: unbox to f64
+                        let rhs_val = if rhs_ty.is_native() {
+                            rhs_ty.to_value_expr(&rhs_code)
+                        } else {
+                            rhs_code
+                        };
+                        format!("(match &({}) {{ Value::Number(n) => *n, v => panic!(\"compound assign: expected number, got {{:?}}\", v) }})", rhs_val)
+                    };
+                    let op_str = match op {
+                        CompoundOp::Add => "+=",
+                        CompoundOp::Sub => "-=",
+                        CompoundOp::Mul => "*=",
+                        CompoundOp::Div => "/=",
+                        CompoundOp::Mod => "%=",
+                    };
+                    // Wrap in Value::Number so the expression is a valid Value
+                    return Ok(format!("{{ {} {} {}; Value::Number({}) }}", n, op_str, rhs_f64, n));
+                }
+
+                // ── native String += fast path: push_str ─────────────────────
+                if !is_refcell && var_type == RustType::String && matches!(op, CompoundOp::Add) {
+                    let (rhs_code, rhs_ty) = self.emit_typed_expr(value)?;
+                    let rhs_str = if rhs_ty == RustType::String {
+                        rhs_code
+                    } else {
+                        // Convert rhs Value to display string inline
+                        let rhs_val = if rhs_ty.is_native() {
+                            rhs_ty.to_value_expr(&rhs_code)
+                        } else {
+                            rhs_code
+                        };
+                        format!(
+                            "match &({}) {{ \
+                             Value::String(s) => s.to_string(), \
+                             Value::Number(n) => {{ let i = *n as i64; if (*n - i as f64).abs() < f64::EPSILON {{ i.to_string() }} else {{ n.to_string() }} }}, \
+                             Value::Bool(b) => b.to_string(), \
+                             Value::Null => \"null\".to_string(), \
+                             other => format!(\"{{:?}}\", other) }}",
+                            rhs_val
+                        )
+                    };
+                    // Wrap in Value::String so the expression is a valid Value
+                    return Ok(format!("{{ {}.push_str(&({})); Value::String({}.clone().into()) }}", n, rhs_str, n));
+                }
+
+                // ── fallback: Value path ──────────────────────────────────────
+                // If the variable is native, wrap it as Value before calling ops::
+                let val = self.emit_expr(value)?;
                 let op_fn = match op {
                     CompoundOp::Add => "add",
                     CompoundOp::Sub => "sub",
@@ -2262,11 +2456,20 @@ impl Codegen {
                     CompoundOp::Div => "div",
                     CompoundOp::Mod => "modulo",
                 };
-                if self.refcell_wrapped_vars.contains(name.as_ref()) {
+                if is_refcell {
                     format!(
                         "{{ let _rhs = ({}).clone(); *{}.borrow_mut() = tishlang_runtime::ops::{}(&*{}.borrow(), &_rhs)?; (*{}.borrow()).clone() }}",
                         val, n, op_fn, n, n
                     )
+                } else if var_type.is_native() {
+                    // Wrap native lhs as Value, run ops::, unbox result back to native
+                    let n_as_value = var_type.to_value_expr(&n);
+                    let result_native = var_type.from_value_expr("_result");
+                    let n_as_value2 = var_type.to_value_expr(&n);
+                    format!(
+                        "{{ let _lhs = {}; let _rhs = ({}).clone(); let _result = tishlang_runtime::ops::{}(&_lhs, &_rhs)?; {} = {}; {} }}",
+                        n_as_value, val, op_fn, n, result_native, n_as_value2
+                    )
                 } else {
                     format!(
                         "{{ let _rhs = ({}).clone(); {} = tishlang_runtime::ops::{}(&{}, &_rhs)?; {}.clone() }}",
@@ -2278,6 +2481,35 @@ impl Codegen {
                 let val = self.emit_expr(value)?;
                 let n = Self::escape_ident(name.as_ref()).into_owned();
                 let is_refcell = self.refcell_wrapped_vars.contains(name.as_ref());
+                let var_type = self.type_context.get_type(name.as_ref());
+
+                // ── native type: wrap for condition, unbox for assignment ──────
+                if !is_refcell && var_type.is_native() {
+                    // n_as_value uses .clone() for String so we don't consume n
+                    let n_as_value = var_type.to_value_expr(&n);
+                    let val_as_native = var_type.from_value_expr("_v");
+                    let (cond, assign_and_return, else_expr) = match op {
+                        LogicalAssignOp::AndAnd => (
+                            format!("{{ let __chk = {}; __chk.is_truthy() }}", n_as_value),
+                            format!("{{ let _v = ({}).clone(); {} = {}; {} }}", val, n, val_as_native, var_type.to_value_expr(&n)),
+                            var_type.to_value_expr(&n),
+                        ),
+                        LogicalAssignOp::OrOr => (
+                            format!("!{{ let __chk = {}; __chk.is_truthy() }}", n_as_value),
+                            format!("{{ let _v = ({}).clone(); {} = {}; {} }}", val, n, val_as_native, var_type.to_value_expr(&n)),
+                            var_type.to_value_expr(&n),
+                        ),
+                        // Native types (f64, String, bool) are never null — ??= is a no-op
+                        LogicalAssignOp::Nullish => (
+                            "false".to_string(),
+                            var_type.to_value_expr(&n), // unreachable but must type-check
+                            var_type.to_value_expr(&n),
+                        ),
+                    };
+                    return Ok(format!("{{ if {} {{ {} }} else {{ {} }} }}", cond, assign_and_return, else_expr));
+                }
+
+                // ── Value / refcell path ──────────────────────────────────────
                 let (cond, assign_and_return, else_expr) = if is_refcell {
                     match op {
                         LogicalAssignOp::AndAnd => (
@@ -2328,6 +2560,43 @@ impl Codegen {
                 )
             }
             Expr::IndexAssign { object, index, value, .. } => {
+                // Native fast path: Vec<T>[i] = v
+                if let Expr::Ident { name, .. } = object.as_ref() {
+                    if !self.refcell_wrapped_vars.contains(name.as_ref()) {
+                        let obj_type = self.type_context.get_type(name.as_ref());
+                        if let RustType::Vec(elem_type) = obj_type {
+                            let esc_obj = Self::escape_ident(name.as_ref()).into_owned();
+                            let (idx_code, idx_ty) = self.emit_typed_expr(index)?;
+                            let idx_usize = if idx_ty == RustType::F64 {
+                                format!("({}) as usize", idx_code)
+                            } else {
+                                let iv = if idx_ty.is_native() {
+                                    idx_ty.to_value_expr(&idx_code)
+                                } else {
+                                    idx_code
+                                };
+                                format!(
+                                    "{{ let _i = &{}; if let Value::Number(n) = _i {{ *n as usize }} else {{ panic!(\"array index must be a number\") }} }}",
+                                    iv
+                                )
+                            };
+                            let (val_code, val_ty) = self.emit_typed_expr(value)?;
+                            let native_val = if val_ty == *elem_type {
+                                val_code
+                            } else if val_ty == RustType::Value {
+                                elem_type.from_value_expr(&val_code)
+                            } else {
+                                // both native but different type — best effort
+                                val_code
+                            };
+                            return Ok(format!(
+                                "{{ {}[{}] = {}; Value::Null }}",
+                                esc_obj, idx_usize, native_val
+                            ));
+                        }
+                    }
+                }
+                // Fallback: runtime set_index
                 let obj = self.emit_expr(object)?;
                 let idx = self.emit_expr(index)?;
                 let val = self.emit_expr(value)?;
@@ -2338,8 +2607,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 +2625,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 +2705,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 +2916,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 +3038,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 +3071,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 +3129,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 +3386,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 +3397,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 +3456,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 +3500,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
@@ -3276,6 +3634,146 @@ impl Codegen {
         Ok(target_type.from_value_expr(&value_expr))
     }
 
+    /// Emit an expression and return `(code, type)`.
+    ///
+    /// When `type` is a native type (`F64`, `Bool`, `String`, `Vec<T>`, …), `code`
+    /// evaluates to a Rust value of that type directly — **not** a `Value`.
+    /// When `type` is `RustType::Value`, `code` evaluates to a `Value`.
+    ///
+    /// This is the fast-path used by callers that want to propagate native types
+    /// through arithmetic, indexing, and assignments.  For any expression this
+    /// function cannot handle natively, it falls back to `emit_expr` and returns
+    /// `RustType::Value`.
+    fn emit_typed_expr(&mut self, expr: &Expr) -> Result<(String, RustType), CompileError> {
+        match expr {
+            // ── literals ─────────────────────────────────────────────────────────
+            Expr::Literal { value, .. } => match value {
+                Literal::Number(n) => Ok((format!("{}_f64", n), RustType::F64)),
+                Literal::String(s) => Ok((format!("{:?}.to_string()", s.as_ref()), RustType::String)),
+                Literal::Bool(b) => Ok((format!("{}", b), RustType::Bool)),
+                Literal::Null => Ok(("Value::Null".to_string(), RustType::Value)),
+            },
+
+            // ── identifiers ──────────────────────────────────────────────────────
+            Expr::Ident { name, .. } => {
+                let escaped = Self::escape_ident(name.as_ref());
+                if self.refcell_wrapped_vars.contains(name.as_ref()) {
+                    // RefCell-wrapped: unwrap via borrow and return Value
+                    Ok((format!("(*{}.borrow()).clone()", escaped), RustType::Value))
+                } else {
+                    let var_type = self.type_context.get_type(name.as_ref());
+                    if var_type.is_native() {
+                        Ok((escaped.into_owned(), var_type))
+                    } else {
+                        Ok((escaped.into_owned(), RustType::Value))
+                    }
+                }
+            }
+
+            // ── binary expressions ───────────────────────────────────────────────
+            Expr::Binary { left, op, right, span, .. } => {
+                let (l, lt) = self.emit_typed_expr(left)?;
+                let (r, rt) = self.emit_typed_expr(right)?;
+
+                if let Some(result_ty) = RustType::result_type_of_binop(*op, &lt, &rt) {
+                    // Both sides are compatible native types → emit native op.
+                    let code = match op {
+                        BinOp::Add => format!("({} + {})", l, r),
+                        BinOp::Sub => format!("({} - {})", l, r),
+                        BinOp::Mul => format!("({} * {})", l, r),
+                        BinOp::Div => format!("({} / {})", l, r),
+                        BinOp::Mod => format!("({} % {})", l, r),
+                        BinOp::Pow => format!("({}).powf({})", l, r),
+                        BinOp::Lt => format!("({} < {})", l, r),
+                        BinOp::Le => format!("({} <= {})", l, r),
+                        BinOp::Gt => format!("({} > {})", l, r),
+                        BinOp::Ge => format!("({} >= {})", l, r),
+                        BinOp::StrictEq => format!("({} == {})", l, r),
+                        BinOp::StrictNe => format!("({} != {})", l, r),
+                        BinOp::And => format!("({} && {})", l, r),
+                        BinOp::Or => format!("({} || {})", l, r),
+                        _ => unreachable!("result_type_of_binop covers all handled ops"),
+                    };
+                    return Ok((code, result_ty));
+                }
+
+                // Fall back: convert both sides to Value and use the runtime.
+                let lv = if lt.is_native() { lt.to_value_expr(&l) } else { l };
+                let rv = if rt.is_native() { rt.to_value_expr(&r) } else { r };
+                let result = self.emit_binop(&lv, *op, &rv, *span)?;
+                Ok((result, RustType::Value))
+            }
+
+            // ── array indexing ───────────────────────────────────────────────────
+            Expr::Index { object, index, optional, .. } => {
+                // Native fast path: `vec[i]` where vec is Vec<T> and i is numeric.
+                if !optional {
+                    if let Expr::Ident { name, .. } = object.as_ref() {
+                        if !self.refcell_wrapped_vars.contains(name.as_ref()) {
+                            let obj_type = self.type_context.get_type(name.as_ref());
+                            if let RustType::Vec(elem_type) = &obj_type {
+                                let esc_obj = Self::escape_ident(name.as_ref()).into_owned();
+                                let (idx_code, idx_ty) = self.emit_typed_expr(index)?;
+                                let idx_usize = if idx_ty == RustType::F64 {
+                                    format!("({}) as usize", idx_code)
+                                } else {
+                                    let iv = if idx_ty.is_native() {
+                                        idx_ty.to_value_expr(&idx_code)
+                                    } else {
+                                        idx_code
+                                    };
+                                    format!(
+                                        "{{ let _i = &{}; if let Value::Number(n) = _i {{ *n as usize }} else {{ panic!(\"array index must be a number\") }} }}",
+                                        iv
+                                    )
+                                };
+                                let elem_ty = *elem_type.clone();
+                                return Ok((format!("{}[{}]", esc_obj, idx_usize), elem_ty));
+                            }
+                        }
+                    }
+                }
+                // Value fallback: emit runtime code directly to avoid cycles
+                // (emit_expr for !optional Index delegates here, so we must not call emit_expr(expr))
+                let obj = self.emit_expr(object)?;
+                let idx = self.emit_expr(index)?;
+                let result = if *optional {
+                    format!(
+                        "{{ let o = {}.clone(); if matches!(o, Value::Null) {{ Value::Null }} else {{ \
+                         tishlang_runtime::get_index(&o, &{}) }} }}",
+                        obj, idx
+                    )
+                } else {
+                    format!("tishlang_runtime::get_index(&{}, &{})", obj, idx)
+                };
+                Ok((result, RustType::Value))
+            }
+
+            // ── everything else: delegate to emit_expr ───────────────────────────
+            _ => {
+                let result = self.emit_expr(expr)?;
+                Ok((result, RustType::Value))
+            }
+        }
+    }
+
+    /// Emit a condition expression as a Rust `bool`.
+    ///
+    /// Returns a `bool`-typed Rust expression when the condition can be
+    /// determined to be native (e.g. `i < N` where both are `f64`), otherwise
+    /// falls back to `{value}.is_truthy()`.
+    fn emit_cond_expr(&mut self, expr: &Expr) -> Result<String, CompileError> {
+        let (code, ty) = self.emit_typed_expr(expr)?;
+        if ty == RustType::Bool {
+            Ok(code)
+        } else if ty.is_native() {
+            // Non-bool native type: convert to Value and use is_truthy
+            Ok(format!("{}.is_truthy()", ty.to_value_expr(&code)))
+        } else {
+            Ok(format!("{}.is_truthy()", code))
+        }
+    }
+
     fn emit_binop(
         &self,
         l: &str,