@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_compile/src/codegen.rs

@@ -1,11 +1,15 @@
 //! Code generation: AST -> Rust source.
 
+use crate::resolve::is_builtin_native_spec;
+use crate::types::{RustType, TypeContext};
 use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
-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};
+use tishlang_ast::{
+    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
+    FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Span, Statement,
+    TypeAnnotation, UnaryOp,
+};
 
 /// Tracks variable usage for move/clone optimization.
 /// A variable can be moved instead of cloned if it's at its last use.
@@ -41,7 +45,12 @@ impl UsageAnalyzer {
                     self.analyze_expr(e);
                 }
             }
-            Statement::If { cond, then_branch, else_branch, .. } => {
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 self.analyze_expr(cond);
                 self.analyze_statement(then_branch);
                 if let Some(e) = else_branch {
@@ -49,7 +58,13 @@ impl UsageAnalyzer {
                 }
             }
             Statement::Block { statements, .. } => self.analyze_statements(statements),
-            Statement::For { init, cond, update, body, .. } => {
+            Statement::For {
+                init,
+                cond,
+                update,
+                body,
+                ..
+            } => {
                 if let Some(i) = init {
                     self.analyze_statement(i);
                 }
@@ -69,7 +84,12 @@ impl UsageAnalyzer {
                 self.analyze_expr(cond);
                 self.analyze_statement(body);
             }
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 self.analyze_expr(expr);
                 for (case_expr, stmts) in cases {
                     if let Some(e) = case_expr {
@@ -82,7 +102,12 @@ impl UsageAnalyzer {
                 }
             }
             Statement::Throw { value, .. } => self.analyze_expr(value),
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 self.analyze_statement(body);
                 if let Some(c) = catch_body {
                     self.analyze_statement(c);
@@ -95,7 +120,11 @@ impl UsageAnalyzer {
                 self.analyze_statement(body);
             }
             Statement::Break { .. } | Statement::Continue { .. } => {}
-            Statement::Import { .. } | Statement::Export { .. } => {
+            Statement::Import { .. }
+            | Statement::Export { .. }
+            | Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {
                 // Import/Export should be resolved by merge_modules before compilation
             }
         }
@@ -153,14 +182,17 @@ impl UsageAnalyzer {
                     }
                 }
             }
-            Expr::ArrowFunction { body, .. } => {
-                match body {
-                    ArrowBody::Expr(e) => self.analyze_expr(e),
-                    ArrowBody::Block(s) => self.analyze_statement(s),
-                }
-            }
+            Expr::ArrowFunction { body, .. } => match body {
+                ArrowBody::Expr(e) => self.analyze_expr(e),
+                ArrowBody::Block(s) => self.analyze_statement(s),
+            },
             Expr::Assign { value, .. } => self.analyze_expr(value),
-            Expr::Conditional { cond, then_branch, else_branch, .. } => {
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 self.analyze_expr(cond);
                 self.analyze_expr(then_branch);
                 self.analyze_expr(else_branch);
@@ -183,23 +215,37 @@ impl UsageAnalyzer {
                 *self.use_counts.entry(name.to_string()).or_insert(0) += 1;
                 self.analyze_expr(value);
             }
-            Expr::PostfixInc { name, .. } | Expr::PostfixDec { name, .. } | Expr::PrefixInc { name, .. } | Expr::PrefixDec { name, .. } => {
+            Expr::PostfixInc { name, .. }
+            | Expr::PostfixDec { name, .. }
+            | Expr::PrefixInc { name, .. }
+            | Expr::PrefixDec { name, .. } => {
                 *self.use_counts.entry(name.to_string()).or_insert(0) += 1;
             }
             Expr::MemberAssign { object, value, .. } => {
                 self.analyze_expr(object);
                 self.analyze_expr(value);
             }
-            Expr::IndexAssign { object, index, value, .. } => {
+            Expr::IndexAssign {
+                object,
+                index,
+                value,
+                ..
+            } => {
                 self.analyze_expr(object);
                 self.analyze_expr(index);
                 self.analyze_expr(value);
             }
             Expr::Await { operand, .. } => self.analyze_expr(operand),
-            Expr::JsxElement { props, children, .. } => {
+            Expr::JsxElement {
+                props, children, ..
+            } => {
                 for p in props {
                     match p {
-                        tishlang_ast::JsxProp::Attr { value: tishlang_ast::JsxAttrValue::Expr(e), .. } | tishlang_ast::JsxProp::Spread(e) => self.analyze_expr(e),
+                        tishlang_ast::JsxProp::Attr {
+                            value: tishlang_ast::JsxAttrValue::Expr(e),
+                            ..
+                        }
+                        | tishlang_ast::JsxProp::Spread(e) => self.analyze_expr(e),
                         _ => {}
                     }
                 }
@@ -240,7 +286,10 @@ pub struct CompileError {
 
 impl CompileError {
     fn new(msg: impl Into<String>, span: Option<Span>) -> Self {
-        Self { message: msg.into(), span }
+        Self {
+            message: msg.into(),
+            span,
+        }
     }
 }
 
@@ -262,21 +311,45 @@ fn program_uses_async(program: &Program) -> bool {
         match s {
             Statement::FunDecl { async_, .. } if *async_ => true,
             Statement::Block { statements, .. } => statements.iter().any(stmt_has_async),
-            Statement::If { then_branch, else_branch, .. } => {
-                stmt_has_async(then_branch) || else_branch.as_ref().is_some_and(|s| stmt_has_async(s.as_ref()))
+            Statement::If {
+                then_branch,
+                else_branch,
+                ..
+            } => {
+                stmt_has_async(then_branch)
+                    || else_branch
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_async(s.as_ref()))
             }
-            Statement::While { body, .. } | Statement::For { body, .. } | Statement::ForOf { body, .. }
+            Statement::While { body, .. }
+            | Statement::For { body, .. }
+            | Statement::ForOf { body, .. }
             | Statement::DoWhile { body, .. } => stmt_has_async(body),
-            Statement::Switch { cases, default_body, .. } => {
-                cases.iter().any(|(_, stmts)| stmts.iter().any(stmt_has_async))
+            Statement::Switch {
+                cases,
+                default_body,
+                ..
+            } => {
+                cases
+                    .iter()
+                    .any(|(_, stmts)| stmts.iter().any(stmt_has_async))
                     || default_body
                         .as_ref()
                         .is_some_and(|stmts| stmts.iter().any(stmt_has_async))
             }
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 stmt_has_async(body)
-                    || catch_body.as_ref().is_some_and(|s| stmt_has_async(s.as_ref()))
-                    || finally_body.as_ref().is_some_and(|s| stmt_has_async(s.as_ref()))
+                    || catch_body
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_async(s.as_ref()))
+                    || finally_body
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_async(s.as_ref()))
             }
             _ => false,
         }
@@ -287,14 +360,16 @@ fn program_uses_async(program: &Program) -> bool {
             Expr::Binary { left, right, .. } => expr_has_await(left) || expr_has_await(right),
             Expr::Unary { operand, .. } | Expr::TypeOf { operand, .. } => expr_has_await(operand),
             Expr::Call { callee, args, .. } => {
-                expr_has_await(callee) || args.iter().any(|a| match a {
-                    CallArg::Expr(e) | CallArg::Spread(e) => expr_has_await(e),
-                })
+                expr_has_await(callee)
+                    || args.iter().any(|a| match a {
+                        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_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)
@@ -305,32 +380,48 @@ fn program_uses_async(program: &Program) -> bool {
                     }
             }
             Expr::Index { object, index, .. } => expr_has_await(object) || expr_has_await(index),
-            Expr::Conditional { cond, then_branch, else_branch, .. } => {
-                expr_has_await(cond) || expr_has_await(then_branch) || expr_has_await(else_branch)
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => expr_has_await(cond) || expr_has_await(then_branch) || expr_has_await(else_branch),
+            Expr::NullishCoalesce { left, right, .. } => {
+                expr_has_await(left) || expr_has_await(right)
             }
-            Expr::NullishCoalesce { left, right, .. } => expr_has_await(left) || expr_has_await(right),
             Expr::Array { elements, .. } => elements.iter().any(|el| match el {
                 ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_has_await(e),
             }),
             Expr::Object { props, .. } => props.iter().any(|p| match p {
                 ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_has_await(e),
             }),
-            Expr::Assign { value, .. } | Expr::CompoundAssign { value, .. } | Expr::LogicalAssign { value, .. }
-            | Expr::MemberAssign { value, .. } | Expr::IndexAssign { value, .. } => expr_has_await(value),
+            Expr::Assign { value, .. }
+            | Expr::CompoundAssign { value, .. }
+            | Expr::LogicalAssign { value, .. }
+            | Expr::MemberAssign { value, .. }
+            | Expr::IndexAssign { value, .. } => expr_has_await(value),
             Expr::ArrowFunction { body, .. } => match body {
                 ArrowBody::Expr(e) => expr_has_await(e),
                 ArrowBody::Block(s) => stmt_has_async(s),
             },
             Expr::TemplateLiteral { exprs, .. } => exprs.iter().any(expr_has_await),
-            Expr::JsxElement { props, children, .. } => {
+            Expr::JsxElement {
+                props, children, ..
+            } => {
                 props.iter().any(|p| match p {
-                    tishlang_ast::JsxProp::Attr { value: tishlang_ast::JsxAttrValue::Expr(e), .. } | tishlang_ast::JsxProp::Spread(e) => expr_has_await(e),
+                    tishlang_ast::JsxProp::Attr {
+                        value: tishlang_ast::JsxAttrValue::Expr(e),
+                        ..
+                    }
+                    | tishlang_ast::JsxProp::Spread(e) => expr_has_await(e),
                     _ => false,
-                }) || children.iter().any(|c| matches!(c, tishlang_ast::JsxChild::Expr(e) if expr_has_await(e)))
-            }
-            Expr::JsxFragment { children, .. } => {
-                children.iter().any(|c| matches!(c, tishlang_ast::JsxChild::Expr(e) if expr_has_await(e)))
+                }) || children
+                    .iter()
+                    .any(|c| matches!(c, tishlang_ast::JsxChild::Expr(e) if expr_has_await(e)))
             }
+            Expr::JsxFragment { children, .. } => children
+                .iter()
+                .any(|c| matches!(c, tishlang_ast::JsxChild::Expr(e) if expr_has_await(e))),
             _ => false,
         }
     }
@@ -340,21 +431,42 @@ fn program_uses_async(program: &Program) -> bool {
             Statement::VarDecl { init, .. } => init.as_ref().is_some_and(expr_has_await),
             Statement::VarDeclDestructure { init, .. } => expr_has_await(init),
             Statement::ExprStmt { expr, .. } => expr_has_await(expr),
-            Statement::If { cond, then_branch, else_branch, .. } => {
-                expr_has_await(cond) || stmt_has_await(then_branch)
-                    || else_branch.as_ref().is_some_and(|s| stmt_has_await(s.as_ref()))
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
+                expr_has_await(cond)
+                    || stmt_has_await(then_branch)
+                    || else_branch
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_await(s.as_ref()))
             }
             Statement::While { cond, body, .. } => expr_has_await(cond) || stmt_has_await(body),
-            Statement::For { init, cond, update, body, .. } => {
+            Statement::For {
+                init,
+                cond,
+                update,
+                body,
+                ..
+            } => {
                 init.as_ref().is_some_and(|s| stmt_has_await(s.as_ref()))
                     || cond.as_ref().is_some_and(expr_has_await)
                     || update.as_ref().is_some_and(expr_has_await)
                     || stmt_has_await(body)
             }
-            Statement::ForOf { iterable, body, .. } => expr_has_await(iterable) || stmt_has_await(body),
+            Statement::ForOf { iterable, body, .. } => {
+                expr_has_await(iterable) || stmt_has_await(body)
+            }
             Statement::Return { value, .. } => value.as_ref().is_some_and(expr_has_await),
             Statement::FunDecl { body, .. } => stmt_has_await(body),
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 expr_has_await(expr)
                     || cases.iter().any(|(c, stmts)| {
                         c.as_ref().is_some_and(expr_has_await) || stmts.iter().any(stmt_has_await)
@@ -365,23 +477,38 @@ fn program_uses_async(program: &Program) -> bool {
             }
             Statement::DoWhile { body, cond, .. } => stmt_has_await(body) || expr_has_await(cond),
             Statement::Throw { value, .. } => expr_has_await(value),
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 stmt_has_await(body)
-                    || catch_body.as_ref().is_some_and(|s| stmt_has_await(s.as_ref()))
-                    || finally_body.as_ref().is_some_and(|s| stmt_has_await(s.as_ref()))
+                    || catch_body
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_await(s.as_ref()))
+                    || finally_body
+                        .as_ref()
+                        .is_some_and(|s| stmt_has_await(s.as_ref()))
             }
             Statement::Import { .. } | Statement::Export { .. } => false,
             _ => false,
         }
     }
-    program.statements.iter().any(|s| stmt_has_async(s) || stmt_has_await(s))
+    program
+        .statements
+        .iter()
+        .any(|s| stmt_has_async(s) || stmt_has_await(s))
 }
 
 pub fn compile(program: &Program) -> Result<String, CompileError> {
     compile_with_project_root(program, None)
 }
 
-pub fn compile_with_project_root(program: &Program, project_root: Option<&Path>) -> Result<String, CompileError> {
+pub fn compile_with_project_root(
+    program: &Program,
+    project_root: Option<&Path>,
+) -> Result<String, CompileError> {
     compile_with_features(program, project_root, &[])
 }
 
@@ -416,24 +543,40 @@ pub fn compile_project_full(
 > {
     use crate::resolve;
     let root = project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
-    let modules = resolve::resolve_project(entry_path, project_root)
-        .map_err(|e| CompileError { message: e, span: None })?;
-    resolve::detect_cycles(&modules)
-        .map_err(|e| CompileError { message: e, span: None })?;
-    let merged = resolve::merge_modules(modules)
-        .map_err(|e| CompileError { message: e, span: None })?;
-    let native_modules = resolve::resolve_native_modules(&merged, root)
-        .map_err(|e| CompileError { message: e, span: None })?;
-    let native_build = resolve::compute_native_build_artifacts(&merged, root, &native_modules)
-        .map_err(|e| CompileError { message: e, span: None })?;
+    let modules = resolve::resolve_project(entry_path, project_root).map_err(|e| CompileError {
+        message: e,
+        span: None,
+    })?;
+    resolve::detect_cycles(&modules).map_err(|e| CompileError {
+        message: e,
+        span: None,
+    })?;
+    let merged = resolve::merge_modules(modules).map_err(|e| CompileError {
+        message: e,
+        span: None,
+    })?;
+    let native_modules =
+        resolve::resolve_native_modules(&merged.program, root).map_err(|e| CompileError {
+            message: e,
+            span: None,
+        })?;
+    let native_build = resolve::compute_native_build_artifacts(
+        &merged.program,
+        root,
+        &native_modules,
+    )
+        .map_err(|e| CompileError {
+            message: e,
+            span: None,
+        })?;
     let mut all_features: Vec<String> = features.to_vec();
-    for f in resolve::extract_native_import_features(&merged) {
+    for f in resolve::extract_native_import_features(&merged.program) {
         if !all_features.contains(&f) {
             all_features.push(f);
         }
     }
     let rust = compile_with_native_modules(
-        &merged,
+        &merged.program,
         project_root,
         &all_features,
         &native_modules,
@@ -463,7 +606,11 @@ pub fn compile_with_native_modules(
     native_init: &std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     optimize: bool,
 ) -> Result<String, CompileError> {
-    let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
+    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);
@@ -521,8 +668,20 @@ struct Codegen {
     usage_analyzer: Option<UsageAnalyzer>,
     /// Type context for tracking variable types (for static typing)
     type_context: TypeContext,
+    /// Registry of `type Foo = { ... }` declarations seen in the program.
+    /// Populated in a pre-pass so that any later `let x: Foo = ...` or
+    /// `fn f(x: Foo)` resolves to a `RustType::Named { name: "Foo", ... }`
+    /// and the codegen can emit a Rust struct + direct field access for
+    /// values of that type.
+    type_aliases: std::collections::HashMap<String, crate::types::RustType>,
     /// Program uses JSX; emit `tishlang_ui` imports and `h` / `Fragment` globals.
     program_has_jsx: bool,
+    /// `fn` names for Rust JSX: PascalCase tags matching these use a value binding; others are string intrinsics.
+    program_fun_decl_names: std::collections::HashSet<String>,
+    /// Nesting depth inside `Value::native(move |args| {{ ... }})` user functions / arrows.
+    /// `try`/`throw` lowering uses `return Err` only at depth 0 (e.g. `run()`); inside native
+    /// closures it must not return a `Result` from a `Value`-returning closure.
+    value_fn_depth: u32,
 }
 
 impl Codegen {
@@ -549,7 +708,191 @@ impl Codegen {
             rc_cell_storage_scopes: vec![std::collections::HashSet::new()],
             usage_analyzer: None,
             type_context: TypeContext::new(),
+            type_aliases: std::collections::HashMap::new(),
             program_has_jsx: false,
+            program_fun_decl_names: std::collections::HashSet::new(),
+            value_fn_depth: 0,
+        }
+    }
+
+    /// Walk every `Statement::TypeAlias` in the program (including nested
+    /// ones inside blocks, ifs, loops, function bodies, and exports) and
+    /// register the resolved `RustType` under its alias name. Forward
+    /// references are handled by running this pass *before* any other
+    /// codegen step.
+    fn collect_type_aliases(&mut self, statements: &[Statement]) {
+        // Two passes so an alias `type B = A` can resolve `A` even if
+        // `A` is declared after `B` in source order.
+        let mut raw: Vec<(String, &TypeAnnotation)> = Vec::new();
+        Self::walk_type_aliases(statements, &mut raw);
+        // First-fixpoint resolution: keep iterating until no more aliases
+        // change shape. In practice 1–2 passes; capped to prevent infinite
+        // loops on (already rejected) self-referential aliases.
+        for _ in 0..8 {
+            let mut changed = false;
+            for (name, ann) in &raw {
+                let resolved = crate::types::RustType::from_annotation_with_aliases(
+                    ann,
+                    &self.type_aliases,
+                );
+                let prev: Option<crate::types::RustType> =
+                    self.type_aliases.get(name).cloned();
+                if prev.as_ref() != Some(&resolved) {
+                    self.type_aliases.insert(name.clone(), resolved);
+                    changed = true;
+                }
+            }
+            if !changed {
+                break;
+            }
+        }
+    }
+
+    fn walk_type_aliases<'p>(
+        statements: &'p [Statement],
+        out: &mut Vec<(String, &'p TypeAnnotation)>,
+    ) {
+        for s in statements {
+            match s {
+                Statement::TypeAlias { name, ty, .. } => {
+                    out.push((name.to_string(), ty));
+                }
+                Statement::Block { statements, .. } => Self::walk_type_aliases(statements, out),
+                Statement::If {
+                    then_branch,
+                    else_branch,
+                    ..
+                } => {
+                    Self::walk_type_aliases(std::slice::from_ref(then_branch.as_ref()), out);
+                    if let Some(e) = else_branch {
+                        Self::walk_type_aliases(std::slice::from_ref(e.as_ref()), out);
+                    }
+                }
+                Statement::For { body, .. }
+                | Statement::ForOf { body, .. }
+                | Statement::While { body, .. }
+                | Statement::DoWhile { body, .. } => {
+                    Self::walk_type_aliases(std::slice::from_ref(body.as_ref()), out);
+                }
+                Statement::Export { declaration, .. } => {
+                    if let tishlang_ast::ExportDeclaration::Named(s) = declaration.as_ref() {
+                        Self::walk_type_aliases(std::slice::from_ref(s.as_ref()), out);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Emit a Rust `struct` definition for every type alias whose RHS is
+    /// an object shape. Each generated struct derives `Clone` + `Debug`
+    /// (cheap; field types are all `Copy`-or-cheap-clone in practice) and
+    /// is named `TishStruct_<TishAlias>`.
+    fn emit_named_struct_decls(&mut self) {
+        // Snapshot keys + values so we can mutate `self` (writing the
+        // emitted source) inside the loop.
+        let mut entries: Vec<(String, crate::types::RustType)> =
+            self.type_aliases.iter().map(|(k, v)| (k.clone(), v.clone())).collect();
+        entries.sort_by(|a, b| a.0.cmp(&b.0));
+        let mut emitted_any = false;
+        for (name, ty) in entries {
+            if let crate::types::RustType::Named { fields, .. }
+            | crate::types::RustType::Object(fields)
+            // ^^ also accept inline shapes registered as aliases — though
+            //    `from_annotation_with_aliases` should always have lifted
+            //    them to `Named` by now.
+                = &ty
+            {
+                let struct_name = crate::types::named_struct_ident(&name);
+                self.write(&format!("#[derive(Clone, Debug, Default)]\n"));
+                self.write("#[allow(non_snake_case, non_camel_case_types)]\n");
+                self.write(&format!("pub struct {} {{\n", struct_name));
+                for (k, t) in fields {
+                    self.write(&format!(
+                        "    pub {}: {},\n",
+                        crate::types::field_ident(k),
+                        t.to_rust_type_str()
+                    ));
+                }
+                self.write("}\n\n");
+
+                // Emit a hand-rolled JSON serialiser per struct so
+                // `JSON.stringify(typed_value)` (and `Vec<TishStruct_X>`)
+                // can bypass the `Value::Object` allocation entirely —
+                // we walk the struct's fields by name and write directly
+                // into the response buffer. ASCII-fast string escape is
+                // shared with the `Value` path via the
+                // `escape_json_string_into` helper that the runtime
+                // re-exports from `tishlang_core::json`.
+                self.write(&format!("impl {} {{\n", struct_name));
+                self.write("    pub fn _tish_write_json(&self, buf: &mut String) {\n");
+                self.write("        use std::fmt::Write as _;\n");
+                self.write("        buf.push('{');\n");
+                for (i, (k, t)) in fields.iter().enumerate() {
+                    let sep = if i == 0 { "{" } else { ",{" };
+                    let prefix = if i == 0 {
+                        format!("\"\\\"{}\\\":\"", k.as_ref())
+                    } else {
+                        format!("\",\\\"{}\\\":\"", k.as_ref())
+                    };
+                    let _ = sep; // (lint silence; we built `prefix` above directly)
+                    self.write(&format!("        buf.push_str({});\n", prefix));
+                    let access = format!("self.{}", crate::types::field_ident(k));
+                    match t {
+                        crate::types::RustType::F64 => {
+                            self.write(&format!(
+                                "        if {a}.is_nan() || {a}.is_infinite() {{ buf.push_str(\"null\"); }} else {{ let _ = write!(buf, \"{{}}\", {a}); }}\n",
+                                a = access
+                            ));
+                        }
+                        crate::types::RustType::Bool => {
+                            self.write(&format!(
+                                "        buf.push_str(if {} {{ \"true\" }} else {{ \"false\" }});\n",
+                                access
+                            ));
+                        }
+                        crate::types::RustType::String => {
+                            self.write(&format!(
+                                "        buf.push('\"'); tishlang_runtime::json::escape_into(buf, {}.as_str()); buf.push('\"');\n",
+                                access
+                            ));
+                        }
+                        crate::types::RustType::Named { .. } => {
+                            self.write(&format!(
+                                "        {}._tish_write_json(buf);\n",
+                                access
+                            ));
+                        }
+                        crate::types::RustType::Vec(inner) if matches!(
+                            inner.as_ref(),
+                            crate::types::RustType::Named { .. }
+                        ) => {
+                            self.write("        buf.push('[');\n");
+                            self.write(&format!(
+                                "        for (i, item) in {}.iter().enumerate() {{ if i > 0 {{ buf.push(','); }} item._tish_write_json(buf); }}\n",
+                                access
+                            ));
+                            self.write("        buf.push(']');\n");
+                        }
+                        _ => {
+                            // Fallback: convert the field to a Value and
+                            // delegate to the dynamic stringifier.
+                            let v_expr = t.to_value_expr(&access);
+                            self.write(&format!(
+                                "        let _v: Value = {}; tishlang_runtime::json::stringify_into(buf, &_v);\n",
+                                v_expr
+                            ));
+                        }
+                    }
+                }
+                self.write("        buf.push('}');\n");
+                self.write("    }\n");
+                self.write("}\n\n");
+                emitted_any = true;
+            }
+        }
+        if emitted_any {
+            self.write("\n");
         }
     }
 
@@ -595,39 +938,47 @@ impl Codegen {
     fn builtin_native_module_rust_init(&self, spec: &str, export_name: &str) -> Option<String> {
         let init = match spec {
             "tish:fs" if self.has_feature("fs") => match export_name {
-                    "readFile" => Some("Value::Function(Rc::new(|args: &[Value]| tish_read_file(args)))"),
-                    "writeFile" => Some("Value::Function(Rc::new(|args: &[Value]| tish_write_file(args)))"),
-                    "fileExists" => Some("Value::Function(Rc::new(|args: &[Value]| tish_file_exists(args)))"),
-                    "isDir" => Some("Value::Function(Rc::new(|args: &[Value]| tish_is_dir(args)))"),
-                    "readDir" => Some("Value::Function(Rc::new(|args: &[Value]| tish_read_dir(args)))"),
-                    "mkdir" => Some("Value::Function(Rc::new(|args: &[Value]| tish_mkdir(args)))"),
+                    "readFile" => Some("Value::native(|args: &[Value]| tish_read_file(args))"),
+                    "writeFile" => Some("Value::native(|args: &[Value]| tish_write_file(args))"),
+                    "fileExists" => Some("Value::native(|args: &[Value]| tish_file_exists(args))"),
+                    "isDir" => Some("Value::native(|args: &[Value]| tish_is_dir(args))"),
+                    "readDir" => Some("Value::native(|args: &[Value]| tish_read_dir(args))"),
+                    "mkdir" => Some("Value::native(|args: &[Value]| tish_mkdir(args))"),
                     _ => None,
                 },
             "tish:http" if self.has_feature("http") => match export_name {
-                    "fetch" => Some("Value::Function(Rc::new(|args: &[Value]| tish_fetch_promise(args.to_vec())))"),
-                    "fetchAll" => Some("Value::Function(Rc::new(|args: &[Value]| tish_fetch_all_promise(args.to_vec())))"),
-                    "serve" => Some("Value::Function(Rc::new(|args: &[Value]| { let port = args.first().cloned().unwrap_or(Value::Null); let handler = args.get(1).cloned().unwrap_or(Value::Null); if let Value::Function(f) = handler { tish_http_serve(args, move |req_args| f(req_args)) } else { Value::Null } }))"),
+                    "fetch" => Some("Value::native(|args: &[Value]| tish_fetch_promise(args.to_vec()))"),
+                    "fetchAll" => Some("Value::native(|args: &[Value]| tish_fetch_all_promise(args.to_vec()))"),
+                    // `serve(port, handler)` (single shared handler) or
+                    // `serve(port, { onWorker })` (per-worker factory). The
+                    // latter dispatches into `http_serve_per_worker`, which
+                    // calls onWorker once per accept thread to build that
+                    // thread's handler.
+                    "serve" => Some("Value::native(|args: &[Value]| { let handler = args.get(1).cloned().unwrap_or(Value::Null); match handler { Value::Function(f) => tish_http_serve(args, move |req_args| f(req_args)), Value::Object(ref opts) => { let factory = opts.borrow().get(&Arc::from(\"onWorker\")).cloned().unwrap_or(Value::Null); tishlang_runtime::http_serve_per_worker(args, factory) }, _ => Value::Null } })"),
                     "Promise" => Some("tish_promise_object()"),
-                    "setTimeout" => Some("Value::Function(Rc::new(|args: &[Value]| tish_timer_set_timeout(args)))"),
-                    "setInterval" => Some("Value::Function(Rc::new(|_args: &[Value]| panic!(\"setInterval not yet supported in native\")))"),
-                    "clearTimeout" => Some("Value::Function(Rc::new(|args: &[Value]| tish_timer_clear_timeout(args)))"),
-                    "clearInterval" => Some("Value::Function(Rc::new(|_args: &[Value]| Value::Null))"),
+                    _ => None,
+                },
+            "tish:timers" if self.has_feature("timers") => match export_name {
+                    "setTimeout" => Some("Value::native(|args: &[Value]| tish_timer_set_timeout(args))"),
+                    "setInterval" => Some("Value::native(|args: &[Value]| tish_timer_set_interval(args))"),
+                    "clearTimeout" => Some("Value::native(|args: &[Value]| tish_timer_clear_timeout(args))"),
+                    "clearInterval" => Some("Value::native(|args: &[Value]| tish_timer_clear_interval(args))"),
                     _ => None,
                 },
             "tish:process" if self.has_feature("process") => match export_name {
-                    "exit" => Some("Value::Function(Rc::new(|args: &[Value]| tish_process_exit(args)))"),
-                    "cwd" => Some("Value::Function(Rc::new(|args: &[Value]| tish_process_cwd(args)))"),
-                    "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 = 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))) }"),
+                    "exit" => Some("Value::native(|args: &[Value]| tish_process_exit(args))"),
+                    "cwd" => Some("Value::native(|args: &[Value]| tish_process_cwd(args))"),
+                    "exec" => Some("Value::native(|args: &[Value]| tish_process_exec(args))"),
+                    "argv" => Some("Value::Array(VmRef::new(std::env::args().map(|s| Value::String(s.into())).collect()))"),
+                    "env" => Some("Value::Object(VmRef::new(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect()))"),
+                    "process" => Some("{ let mut m = ObjectMap::default(); m.insert(Arc::from(\"exit\"), Value::native(|args: &[Value]| tish_process_exit(args))); m.insert(Arc::from(\"cwd\"), Value::native(|args: &[Value]| tish_process_cwd(args))); m.insert(Arc::from(\"exec\"), Value::native(|args: &[Value]| tish_process_exec(args))); m.insert(Arc::from(\"argv\"), Value::Array(VmRef::new(std::env::args().map(|s| Value::String(s.into())).collect()))); m.insert(Arc::from(\"env\"), Value::Object(VmRef::new(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect::<ObjectMap>()))); Value::Object(VmRef::new(m)) }"),
                     _ => None,
                 },
             "tish:ws" if self.has_feature("ws") => match export_name {
-                    "WebSocket" => Some("Value::Function(Rc::new(|args: &[Value]| tish_ws_client(args)))"),
-                    "Server" => Some("Value::Function(Rc::new(|args: &[Value]| tish_ws_server_construct(args)))"),
-                    "wsSend" => Some("Value::Function(Rc::new(|args: &[Value]| Value::Bool(tishlang_runtime::ws_send_native(args.first().unwrap_or(&Value::Null), &args.get(1).map(|v| v.to_display_string()).unwrap_or_default()))))"),
-                    "wsBroadcast" => Some("Value::Function(Rc::new(|args: &[Value]| tishlang_runtime::ws_broadcast_native(args)))"),
+                    "WebSocket" => Some("Value::native(|args: &[Value]| tish_ws_client(args))"),
+                    "Server" => Some("Value::native(|args: &[Value]| tish_ws_server_construct(args))"),
+                    "wsSend" => Some("Value::native(|args: &[Value]| Value::Bool(tishlang_runtime::ws_send_native(args.first().unwrap_or(&Value::Null), &args.get(1).map(|v| v.to_display_string()).unwrap_or_default())))"),
+                    "wsBroadcast" => Some("Value::native(|args: &[Value]| tishlang_runtime::ws_broadcast_native(args))"),
                     _ => None,
                 },
             _ => return None,
@@ -637,7 +988,7 @@ impl Codegen {
 
     fn has_feature(&self, name: &str) -> bool {
         if self.features.contains("full") {
-            matches!(name, "http" | "fs" | "process" | "regex" | "ws")
+            matches!(name, "http" | "timers" | "fs" | "process" | "regex" | "ws")
         } else {
             self.features.contains(name)
         }
@@ -668,17 +1019,23 @@ impl Codegen {
     /// Escape Rust reserved keywords by prefixing with r#
     fn escape_ident(name: &str) -> Cow<'_, str> {
         // Rust standard library macros that conflict with variable names
-        const RUST_MACROS: &[&str] = &["line", "column", "file", "module_path", "stringify", "concat"];
+        const RUST_MACROS: &[&str] = &[
+            "line",
+            "column",
+            "file",
+            "module_path",
+            "stringify",
+            "concat",
+        ];
         if RUST_MACROS.contains(&name) {
             return Cow::Owned(format!("r#{}", name));
         }
         const RUST_KEYWORDS: &[&str] = &[
-            "as", "async", "await", "break", "const", "continue", "crate", "dyn",
-            "else", "enum", "extern", "false", "fn", "for", "if", "impl", "in",
-            "let", "loop", "match", "mod", "move", "mut", "pub", "ref", "return",
-            "self", "Self", "static", "struct", "super", "trait", "true", "type",
-            "unsafe", "use", "where", "while", "abstract", "become", "box", "do",
-            "final", "macro", "override", "priv", "try", "typeof", "unsized",
+            "as", "async", "await", "break", "const", "continue", "crate", "dyn", "else", "enum",
+            "extern", "false", "fn", "for", "if", "impl", "in", "let", "loop", "match", "mod",
+            "move", "mut", "pub", "ref", "return", "self", "Self", "static", "struct", "super",
+            "trait", "true", "type", "unsafe", "use", "where", "while", "abstract", "become",
+            "box", "do", "final", "macro", "override", "priv", "try", "typeof", "unsized",
             "virtual", "yield",
         ];
         if RUST_KEYWORDS.contains(&name) {
@@ -717,20 +1074,20 @@ impl Codegen {
         if !Self::needs_clone(expr) {
             return false;
         }
-        
+
         // Check for last-use optimization on simple identifiers
         if let Expr::Ident { name, .. } = expr {
             // Don't optimize RefCell-wrapped vars (they're borrowed, not owned)
             if self.refcell_wrapped_vars.contains(name.as_ref()) {
                 return true;
             }
-            
+
             // Inside a loop, any variable used in an init (e.g. "let x = outerVar") must be cloned:
             // the loop body runs multiple times, so we cannot move on the first iteration.
             if !self.loop_stack.is_empty() {
                 return true;
             }
-            
+
             // Check if this is the last use
             if let Some(ref mut analyzer) = self.usage_analyzer {
                 if analyzer.is_last_use(name.as_ref()) {
@@ -738,7 +1095,7 @@ impl Codegen {
                 }
             }
         }
-        
+
         true
     }
 
@@ -806,7 +1163,7 @@ impl Codegen {
     /// Returns Some(true) for ascending, Some(false) for descending, None if not detected
     fn detect_numeric_sort_comparator(expr: &Expr) -> Option<bool> {
         use tishlang_ast::ArrowBody;
-        
+
         if let Expr::ArrowFunction { params, body, .. } = expr {
             if params.len() != 2 {
                 return None;
@@ -819,7 +1176,7 @@ impl Codegen {
                 }
                 _ => return None,
             };
-            
+
             // Body must be a single expression that's a subtraction
             let body_expr = match body {
                 ArrowBody::Expr(e) => e.as_ref(),
@@ -831,10 +1188,24 @@ impl Codegen {
                     }
                 }
             };
-            
-            if let Expr::Binary { left, op: BinOp::Sub, right, .. } = body_expr {
+
+            if let Expr::Binary {
+                left,
+                op: BinOp::Sub,
+                right,
+                ..
+            } = body_expr
+            {
                 // Check for a - b (ascending) or b - a (descending)
-                if let (Expr::Ident { name: left_name, .. }, Expr::Ident { name: right_name, .. }) = (left.as_ref(), right.as_ref()) {
+                if let (
+                    Expr::Ident {
+                        name: left_name, ..
+                    },
+                    Expr::Ident {
+                        name: right_name, ..
+                    },
+                ) = (left.as_ref(), right.as_ref())
+                {
                     if left_name.as_ref() == param_a && right_name.as_ref() == param_b {
                         return Some(true); // ascending
                     }
@@ -850,22 +1221,26 @@ 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.program_fun_decl_names = tishlang_ui::jsx::collect_fun_decl_names(program);
         self.write("#![allow(unused, non_snake_case)]\n\n");
         self.write("use std::cell::RefCell;\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, tish_construct, tish_uint8_array_constructor, tish_audio_context_constructor, ObjectMap, 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, string_escape_html_impl as tish_escape_html, 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, register_static_route as tish_register_static_route, ObjectMap, TishError, Value, VmRef};\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");
         }
+        if self.has_feature("timers") {
+            self.write("use tishlang_runtime::{timer_set_timeout as tish_timer_set_timeout, timer_clear_timeout as tish_timer_clear_timeout, timer_set_interval as tish_timer_set_interval, timer_clear_interval as tish_timer_clear_interval};\n");
+        }
         if self.has_feature("http") {
             if self.is_async {
-                self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve, timer_set_timeout as tish_timer_set_timeout, timer_clear_timeout as tish_timer_clear_timeout, promise_object as tish_promise_object, await_promise as tish_await_promise};\n");
+                self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve, promise_object as tish_promise_object, await_promise as tish_await_promise};\n");
             } else {
-                self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve, timer_set_timeout as tish_timer_set_timeout, timer_clear_timeout as tish_timer_clear_timeout};\n");
+                self.write("use tishlang_runtime::{fetch_promise as tish_fetch_promise, fetch_all_promise as tish_fetch_all_promise, http_serve as tish_http_serve};\n");
             }
         }
         if self.has_feature("fs") {
@@ -879,6 +1254,19 @@ impl Codegen {
         }
         self.write("\n");
 
+        // Collect every `type Foo = { ... }` declaration in the program
+        // (recursive, so they can also live inside blocks / branches) and
+        // canonicalise each into a `RustType::Named` with its field list.
+        // Aliases that resolve to a non-Object shape (e.g. `type N = number`)
+        // are stored too, so later annotations like `let x: N = 0` still
+        // pick up the right native type.
+        self.collect_type_aliases(&program.statements);
+        // Emit a Rust `struct` for every alias whose RHS is an object
+        // shape. Subsequent `let x: Foo = ...` literals lower to plain
+        // struct moves (no `VmRef::new(ObjectMap::from(..))` allocation),
+        // and `x.field` becomes a direct field access.
+        self.emit_named_struct_decls();
+
         if self.is_async {
             self.writeln("#[tokio::main]");
             self.writeln("async fn main() {");
@@ -907,150 +1295,220 @@ impl Codegen {
         self.indent += 1;
 
         // Initialize builtins
-        self.writeln("let mut console = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
+        self.writeln("let mut console = Value::Object(VmRef::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 }))),");
-        self.writeln("(Arc::from(\"log\"), Value::Function(Rc::new(|args: &[Value]| { tish_console_log(args); Value::Null }))),");
-        self.writeln("(Arc::from(\"warn\"), Value::Function(Rc::new(|args: &[Value]| { tish_console_warn(args); Value::Null }))),");
-        self.writeln("(Arc::from(\"error\"), Value::Function(Rc::new(|args: &[Value]| { tish_console_error(args); Value::Null }))),");
+        self.writeln("(Arc::from(\"debug\"), Value::native(|args: &[Value]| { tish_console_debug(args); Value::Null })),");
+        self.writeln("(Arc::from(\"info\"), Value::native(|args: &[Value]| { tish_console_info(args); Value::Null })),");
+        self.writeln("(Arc::from(\"log\"), Value::native(|args: &[Value]| { tish_console_log(args); Value::Null })),");
+        self.writeln("(Arc::from(\"warn\"), Value::native(|args: &[Value]| { tish_console_warn(args); Value::Null })),");
+        self.writeln("(Arc::from(\"error\"), Value::native(|args: &[Value]| { tish_console_error(args); Value::Null })),");
         self.indent -= 1;
-        self.writeln("]))));");
-        self.writeln("let Boolean = Value::Function(Rc::new(|args: &[Value]| tish_boolean(args)));");
-        self.writeln("let parseInt = Value::Function(Rc::new(|args: &[Value]| tish_parse_int(args)));");
-        self.writeln("let parseFloat = Value::Function(Rc::new(|args: &[Value]| tish_parse_float(args)));");
-        self.writeln("let decodeURI = Value::Function(Rc::new(|args: &[Value]| tish_decode_uri(args)));");
-        self.writeln("let encodeURI = Value::Function(Rc::new(|args: &[Value]| tish_encode_uri(args)));");
-        self.writeln("let isFinite = Value::Function(Rc::new(|args: &[Value]| tish_is_finite(args)));");
-        self.writeln("let isNaN = Value::Function(Rc::new(|args: &[Value]| tish_is_nan(args)));");
+        self.writeln("])));");
+        self.writeln(
+            "let Boolean = Value::native(|args: &[Value]| tish_boolean(args));",
+        );
+        self.writeln(
+            "let parseInt = Value::native(|args: &[Value]| tish_parse_int(args));",
+        );
+        self.writeln(
+            "let parseFloat = Value::native(|args: &[Value]| tish_parse_float(args));",
+        );
+        self.writeln(
+            "let decodeURI = Value::native(|args: &[Value]| tish_decode_uri(args));",
+        );
+        self.writeln(
+            "let encodeURI = Value::native(|args: &[Value]| tish_encode_uri(args));",
+        );
+        self.writeln(
+            r#"let registerStaticRoute = Value::native(|args: &[Value]| { let path = match args.get(0) { Some(Value::String(s)) => s.to_string(), _ => return Value::Null }; let body = match args.get(1) { Some(Value::String(s)) => s.as_bytes().to_vec(), _ => return Value::Null }; let ct = match args.get(2) { Some(Value::String(s)) => s.to_string(), _ => "application/octet-stream".to_string() }; tish_register_static_route(&path, &body, &ct); Value::Null });"#,
+        );
+        self.writeln(
+            "let htmlEscape = Value::native(|args: &[Value]| tish_escape_html(args.first().unwrap_or(&Value::Null)));",
+        );
+        self.writeln(
+            "let isFinite = Value::native(|args: &[Value]| tish_is_finite(args));",
+        );
+        self.writeln("let isNaN = Value::native(|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(ObjectMap::from([");
+        self.writeln("let Math = Value::Object(VmRef::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)))),");
-        self.writeln("(Arc::from(\"min\"), Value::Function(Rc::new(|args: &[Value]| tish_math_min(args)))),");
-        self.writeln("(Arc::from(\"max\"), Value::Function(Rc::new(|args: &[Value]| tish_math_max(args)))),");
-        self.writeln("(Arc::from(\"floor\"), Value::Function(Rc::new(|args: &[Value]| tish_math_floor(args)))),");
-        self.writeln("(Arc::from(\"ceil\"), Value::Function(Rc::new(|args: &[Value]| tish_math_ceil(args)))),");
-        self.writeln("(Arc::from(\"round\"), Value::Function(Rc::new(|args: &[Value]| tish_math_round(args)))),");
-        self.writeln("(Arc::from(\"random\"), Value::Function(Rc::new(|args: &[Value]| tish_math_random(args)))),");
-        self.writeln("(Arc::from(\"pow\"), Value::Function(Rc::new(|args: &[Value]| tish_math_pow(args)))),");
-        self.writeln("(Arc::from(\"sin\"), Value::Function(Rc::new(|args: &[Value]| tish_math_sin(args)))),");
-        self.writeln("(Arc::from(\"cos\"), Value::Function(Rc::new(|args: &[Value]| tish_math_cos(args)))),");
-        self.writeln("(Arc::from(\"tan\"), Value::Function(Rc::new(|args: &[Value]| tish_math_tan(args)))),");
-        self.writeln("(Arc::from(\"log\"), Value::Function(Rc::new(|args: &[Value]| tish_math_log(args)))),");
-        self.writeln("(Arc::from(\"exp\"), Value::Function(Rc::new(|args: &[Value]| tish_math_exp(args)))),");
-        self.writeln("(Arc::from(\"sign\"), Value::Function(Rc::new(|args: &[Value]| tish_math_sign(args)))),");
-        self.writeln("(Arc::from(\"trunc\"), Value::Function(Rc::new(|args: &[Value]| tish_math_trunc(args)))),");
+        self.writeln(
+            "(Arc::from(\"abs\"), Value::native(|args: &[Value]| tish_math_abs(args))),",
+        );
+        self.writeln("(Arc::from(\"sqrt\"), Value::native(|args: &[Value]| tish_math_sqrt(args))),");
+        self.writeln(
+            "(Arc::from(\"min\"), Value::native(|args: &[Value]| tish_math_min(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"max\"), Value::native(|args: &[Value]| tish_math_max(args))),",
+        );
+        self.writeln("(Arc::from(\"floor\"), Value::native(|args: &[Value]| tish_math_floor(args))),");
+        self.writeln("(Arc::from(\"ceil\"), Value::native(|args: &[Value]| tish_math_ceil(args))),");
+        self.writeln("(Arc::from(\"round\"), Value::native(|args: &[Value]| tish_math_round(args))),");
+        self.writeln("(Arc::from(\"random\"), Value::native(|args: &[Value]| tish_math_random(args))),");
+        self.writeln(
+            "(Arc::from(\"pow\"), Value::native(|args: &[Value]| tish_math_pow(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"sin\"), Value::native(|args: &[Value]| tish_math_sin(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"cos\"), Value::native(|args: &[Value]| tish_math_cos(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"tan\"), Value::native(|args: &[Value]| tish_math_tan(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"log\"), Value::native(|args: &[Value]| tish_math_log(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"exp\"), Value::native(|args: &[Value]| tish_math_exp(args))),",
+        );
+        self.writeln("(Arc::from(\"sign\"), Value::native(|args: &[Value]| tish_math_sign(args))),");
+        self.writeln("(Arc::from(\"trunc\"), Value::native(|args: &[Value]| tish_math_trunc(args))),");
         self.writeln("(Arc::from(\"PI\"), Value::Number(std::f64::consts::PI)),");
         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(ObjectMap::from([");
+        self.writeln("])));");
+        self.writeln("let JSON = Value::Object(VmRef::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.writeln("(Arc::from(\"parse\"), Value::native(|args: &[Value]| tish_json_parse(args))),");
+        self.writeln("(Arc::from(\"stringify\"), Value::native(|args: &[Value]| tish_json_stringify(args))),");
         self.indent -= 1;
-        self.writeln("]))));");
+        self.writeln("])));");
 
-        self.writeln("let Array = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
+        self.writeln("let Array = Value::Object(VmRef::new(ObjectMap::from([");
         self.indent += 1;
-        self.writeln("(Arc::from(\"isArray\"), Value::Function(Rc::new(|args: &[Value]| tish_array_is_array(args)))),");
+        self.writeln("(Arc::from(\"isArray\"), Value::native(|args: &[Value]| tish_array_is_array(args))),");
         self.indent -= 1;
-        self.writeln("]))));");
+        self.writeln("])));");
 
-        self.writeln("let String = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
+        self.writeln("let String = Value::Object(VmRef::new(ObjectMap::from([");
         self.indent += 1;
-        self.writeln("(Arc::from(\"fromCharCode\"), Value::Function(Rc::new(|args: &[Value]| tish_string_from_char_code(args)))),");
+        self.writeln("(Arc::from(\"fromCharCode\"), Value::native(|args: &[Value]| tish_string_from_char_code(args))),");
         self.indent -= 1;
-        self.writeln("]))));");
+        self.writeln("])));");
 
-        self.writeln("let Date = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
+        self.writeln("let Date = Value::Object(VmRef::new(ObjectMap::from([");
         self.indent += 1;
-        self.writeln("(Arc::from(\"now\"), Value::Function(Rc::new(|args: &[Value]| tish_date_now(args)))),");
+        self.writeln(
+            "(Arc::from(\"now\"), Value::native(|args: &[Value]| tish_date_now(args))),",
+        );
         self.indent -= 1;
-        self.writeln("]))));");
+        self.writeln("])));");
 
-        self.writeln("let Object = Value::Object(Rc::new(RefCell::new(ObjectMap::from([");
+        self.writeln("let Object = Value::Object(VmRef::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)))),");
-        self.writeln("(Arc::from(\"values\"), Value::Function(Rc::new(|args: &[Value]| tish_object_values(args)))),");
-        self.writeln("(Arc::from(\"entries\"), Value::Function(Rc::new(|args: &[Value]| tish_object_entries(args)))),");
-        self.writeln("(Arc::from(\"fromEntries\"), Value::Function(Rc::new(|args: &[Value]| tish_object_from_entries(args)))),");
+        self.writeln("(Arc::from(\"assign\"), Value::native(|args: &[Value]| tish_object_assign(args))),");
+        self.writeln("(Arc::from(\"keys\"), Value::native(|args: &[Value]| tish_object_keys(args))),");
+        self.writeln("(Arc::from(\"values\"), Value::native(|args: &[Value]| tish_object_values(args))),");
+        self.writeln("(Arc::from(\"entries\"), Value::native(|args: &[Value]| tish_object_entries(args))),");
+        self.writeln("(Arc::from(\"fromEntries\"), Value::native(|args: &[Value]| tish_object_from_entries(args))),");
         self.indent -= 1;
-        self.writeln("]))));");
+        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.writeln("let process = Value::Object(VmRef::new({");
             self.indent += 1;
             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("p.insert(Arc::from(\"exit\"), Value::native(|args: &[Value]| tish_process_exit(args)));");
+            self.writeln("p.insert(Arc::from(\"cwd\"), Value::native(|args: &[Value]| tish_process_cwd(args)));");
+            self.writeln("p.insert(Arc::from(\"exec\"), Value::native(|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(
+                "p.insert(Arc::from(\"argv\"), Value::Array(VmRef::new(argv)));",
+            );
             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()));");
             self.indent -= 1;
             self.writeln("}");
-            self.writeln("p.insert(Arc::from(\"env\"), Value::Object(Rc::new(RefCell::new(env_obj))));");
+            self.writeln(
+                "p.insert(Arc::from(\"env\"), Value::Object(VmRef::new(env_obj)));",
+            );
             self.writeln("p");
             self.indent -= 1;
-            self.writeln("})));");
+            self.writeln("}));");
         }
 
+        if self.has_feature("timers") {
+            self.writeln("let setTimeout = Value::native(|args: &[Value]| tish_timer_set_timeout(args));");
+            self.writeln("let clearTimeout = Value::native(|args: &[Value]| tish_timer_clear_timeout(args));");
+            self.writeln("let setInterval = Value::native(|args: &[Value]| tish_timer_set_interval(args));");
+            self.writeln("let clearInterval = Value::native(|args: &[Value]| tish_timer_clear_interval(args));");
+        }
         if self.has_feature("http") {
-            self.writeln("let fetch = Value::Function(Rc::new(|args: &[Value]| tish_fetch_promise(args.to_vec())));");
-            self.writeln("let fetchAll = Value::Function(Rc::new(|args: &[Value]| tish_fetch_all_promise(args.to_vec())));");
-            self.writeln("let setTimeout = Value::Function(Rc::new(|args: &[Value]| tish_timer_set_timeout(args)));");
-            self.writeln("let clearTimeout = Value::Function(Rc::new(|args: &[Value]| tish_timer_clear_timeout(args)));");
+            self.writeln("let fetch = Value::native(|args: &[Value]| tish_fetch_promise(args.to_vec()));");
+            self.writeln("let fetchAll = Value::native(|args: &[Value]| tish_fetch_all_promise(args.to_vec()));");
             if self.is_async {
                 self.writeln("let Promise = tish_promise_object();");
             }
-            self.writeln("let serve = Value::Function(Rc::new(|args: &[Value]| {");
+            // `serve` supports two shapes:
+            //   1. serve(port, handler)            // single shared handler
+            //   2. serve(port, { onWorker: (workerId) => handler, ... })
+            //
+            // Shape (2) lets users build per-worker state (DB connection,
+            // cache, counter, ...) without a global mutex. The runtime
+            // dispatches each accept thread to its own handler, all in
+            // parallel under `send-values`.
+            self.writeln("let serve = Value::native(|args: &[Value]| {");
             self.indent += 1;
-            self.writeln("let port = args.first().cloned().unwrap_or(Value::Null);");
             self.writeln("let handler = args.get(1).cloned().unwrap_or(Value::Null);");
-            self.writeln("if let Value::Function(f) = handler {");
+            self.writeln("match handler {");
             self.indent += 1;
-            self.writeln("tish_http_serve(args, move |req_args| f(req_args))");
-            self.indent -= 1;
-            self.writeln("} else {");
+            self.writeln("Value::Function(f) => tish_http_serve(args, move |req_args| f(req_args)),");
+            self.writeln("Value::Object(ref opts) => {");
             self.indent += 1;
-            self.writeln("Value::Null");
+            self.writeln("let factory = opts.borrow().get(&Arc::from(\"onWorker\")).cloned().unwrap_or(Value::Null);");
+            self.writeln("tishlang_runtime::http_serve_per_worker(args, factory)");
+            self.indent -= 1;
+            self.writeln("},");
+            self.writeln("_ => Value::Null,");
             self.indent -= 1;
             self.writeln("}");
             self.indent -= 1;
-            self.writeln("}));");
+            self.writeln("});");
         }
 
         if self.has_feature("fs") {
-            self.writeln("let readFile = Value::Function(Rc::new(|args: &[Value]| tish_read_file(args)));");
-            self.writeln("let writeFile = Value::Function(Rc::new(|args: &[Value]| tish_write_file(args)));");
-            self.writeln("let fileExists = Value::Function(Rc::new(|args: &[Value]| tish_file_exists(args)));");
-            self.writeln("let isDir = Value::Function(Rc::new(|args: &[Value]| tish_is_dir(args)));");
-            self.writeln("let readDir = Value::Function(Rc::new(|args: &[Value]| tish_read_dir(args)));");
-            self.writeln("let mkdir = Value::Function(Rc::new(|args: &[Value]| tish_mkdir(args)));");
+            self.writeln(
+                "let readFile = Value::native(|args: &[Value]| tish_read_file(args));",
+            );
+            self.writeln(
+                "let writeFile = Value::native(|args: &[Value]| tish_write_file(args));",
+            );
+            self.writeln("let fileExists = Value::native(|args: &[Value]| tish_file_exists(args));");
+            self.writeln(
+                "let isDir = Value::native(|args: &[Value]| tish_is_dir(args));",
+            );
+            self.writeln(
+                "let readDir = Value::native(|args: &[Value]| tish_read_dir(args));",
+            );
+            self.writeln(
+                "let mkdir = Value::native(|args: &[Value]| tish_mkdir(args));",
+            );
         }
 
         if self.has_feature("regex") {
-            self.writeln("let RegExp = Value::Function(Rc::new(|args: &[Value]| regexp_new(args)));");
+            self.writeln(
+                "let RegExp = Value::native(|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)));");
+            self.writeln("let h = Value::native(|args: &[Value]| ui_h(args));");
+            self.writeln("let text = Value::native(|args: &[Value]| ui_text(args));");
+            self.writeln(
+                "let useState = Value::native(|args: &[Value]| native_use_state(args));",
+            );
+            self.writeln("let createRoot = Value::native(|args: &[Value]| native_create_root(args));");
         }
 
         // Polars, Egui etc. are emitted via VarDecl from import { X } from 'tish:...'
@@ -1060,7 +1518,10 @@ impl Codegen {
         *self.function_scope_stack.last_mut().unwrap() = top_level_funcs.clone();
         for func_name in &top_level_funcs {
             let escaped = Self::escape_ident(func_name);
-            self.writeln(&format!("let {}_cell: Rc<RefCell<Value>> = Rc::new(RefCell::new(Value::Null));", escaped));
+            self.writeln(&format!(
+                "let {}_cell: VmRef<Value> = VmRef::new(Value::Null);",
+                escaped
+            ));
         }
 
         // Initialize usage analyzer for move/clone optimization
@@ -1097,9 +1558,11 @@ impl Codegen {
                 self.indent += 1;
                 self.type_context.push_scope();
                 self.outer_vars_stack.push(Vec::new());
-                self.rc_cell_storage_scopes.push(std::collections::HashSet::new());
+                self.rc_cell_storage_scopes
+                    .push(std::collections::HashSet::new());
                 // Prepass: vars that must be RefCell because nested closures capture and mutate them
-                let vars_mutated_by_nested = Self::collect_vars_mutated_by_nested_closures(statements);
+                let vars_mutated_by_nested =
+                    Self::collect_vars_mutated_by_nested_closures(statements);
                 for v in &vars_mutated_by_nested {
                     self.refcell_wrapped_vars.insert(v.clone());
                 }
@@ -1109,7 +1572,10 @@ impl Codegen {
                 // Create cells for all functions in this scope
                 for func_name in &func_names {
                     let escaped = Self::escape_ident(func_name);
-                    self.writeln(&format!("let {}_cell: Rc<RefCell<Value>> = Rc::new(RefCell::new(Value::Null));", escaped));
+                    self.writeln(&format!(
+                        "let {}_cell: VmRef<Value> = VmRef::new(Value::Null);",
+                        escaped
+                    ));
                 }
                 for s in statements {
                     self.emit_statement(s)?;
@@ -1124,19 +1590,30 @@ impl Codegen {
                 self.indent -= 1;
                 self.writeln("}");
             }
-            Statement::VarDecl { name, mutable, type_ann, init, .. } => {
-                // Determine the Rust type from annotation
+            Statement::VarDecl {
+                name,
+                mutable,
+                type_ann,
+                init,
+                ..
+            } => {
+                // Determine the Rust type from annotation, consulting the
+                // user-declared `type` aliases so a `let x: World = ...`
+                // resolves to `RustType::Named { name: "World", fields }`
+                // and we can emit a struct move instead of a Value box.
                 let rust_type = type_ann
                     .as_ref()
-                    .map(RustType::from_annotation)
+                    .map(|t| {
+                        crate::types::RustType::from_annotation_with_aliases(t, &self.type_aliases)
+                    })
                     .unwrap_or(RustType::Value);
 
                 // Track the variable type
                 self.type_context.define(name.as_ref(), rust_type.clone());
-                
+
                 let mutability = if *mutable { "let mut" } else { "let" };
                 let escaped_name = Self::escape_ident(name.as_ref());
-                
+
                 if rust_type.is_native() {
                     // Generate native typed variable
                     let expr_str = match init.as_ref() {
@@ -1146,7 +1623,7 @@ impl Codegen {
                     if self.refcell_wrapped_vars.contains(name.as_ref()) {
                         // Closure-mutated: same Rc<RefCell<T>> pattern as Value (assignments use borrow_mut)
                         self.writeln(&format!(
-                            "let {} = std::rc::Rc::new(RefCell::new({}));",
+                            "let {} = VmRef::new({});",
                             escaped_name, expr_str
                         ));
                         self.rc_cell_storage_define(name.as_ref());
@@ -1164,8 +1641,7 @@ impl Codegen {
                             let s = self.emit_expr(e)?;
                             // Variable refs (Ident) in init must always clone: they may be used
                             // multiple times (e.g. in a loop body) and we cannot move.
-                            let needs = matches!(e, Expr::Ident { .. })
-                                || self.should_clone(e);
+                            let needs = matches!(e, Expr::Ident { .. }) || self.should_clone(e);
                             (s, needs)
                         }
                         None => ("Value::Null".to_string(), false),
@@ -1177,25 +1653,42 @@ impl Codegen {
                         } else {
                             expr_str.to_string()
                         };
-                        self.writeln(&format!("let {} = std::rc::Rc::new(RefCell::new({}));", escaped_name, init_val));
+                        self.writeln(&format!(
+                            "let {} = VmRef::new({});",
+                            escaped_name, init_val
+                        ));
                         self.rc_cell_storage_define(name.as_ref());
                     } else if clone_needed {
-                        self.writeln(&format!("{} {} = ({}).clone();", mutability, escaped_name, expr_str));
+                        self.writeln(&format!(
+                            "{} {} = ({}).clone();",
+                            mutability, escaped_name, expr_str
+                        ));
                     } else {
                         self.writeln(&format!("{} {} = {};", mutability, escaped_name, expr_str));
                     }
                 }
-                
+
                 if let Some(scope) = self.outer_vars_stack.last_mut() {
                     scope.push(name.to_string());
                 }
             }
-            Statement::VarDeclDestructure { pattern, mutable, init, span, .. } => {
+            Statement::VarDeclDestructure {
+                pattern,
+                mutable,
+                init,
+                span,
+                ..
+            } => {
                 let expr = self.emit_expr(init)?;
                 let mutability = if *mutable { "let mut" } else { "let" };
-                let clone_suffix = if Self::needs_clone(init) { ".clone()" } else { "" };
+                let clone_suffix = if Self::needs_clone(init) {
+                    ".clone()"
+                } else {
+                    ""
+                };
                 self.writeln(&format!("let _destruct_val = ({}){};", expr, clone_suffix));
                 self.emit_destruct_bindings(pattern, "_destruct_val", mutability, *span)?;
+                self.register_destruct_pattern_outer_vars(pattern);
             }
             Statement::ExprStmt { expr, .. } => {
                 let e = self.emit_expr(expr)?;
@@ -1232,7 +1725,12 @@ impl Codegen {
                 self.indent -= 1;
                 self.writeln("}");
             }
-            Statement::ForOf { name, iterable, body, .. } => {
+            Statement::ForOf {
+                name,
+                iterable,
+                body,
+                ..
+            } => {
                 let iter_expr = self.emit_expr(iterable)?;
                 self.writeln(&format!("{{ let _fof = ({}).clone();", iter_expr));
                 self.indent += 1;
@@ -1242,7 +1740,10 @@ impl Codegen {
                 self.indent += 1;
                 self.writeln("for _v in _arr.borrow().iter() {");
                 self.indent += 1;
-                self.writeln(&format!("let {} = _v.clone();", Self::escape_ident(name.as_ref())));
+                self.writeln(&format!(
+                    "let {} = _v.clone();",
+                    Self::escape_ident(name.as_ref())
+                ));
                 self.emit_statement(body)?;
                 self.indent -= 1;
                 self.writeln("}");
@@ -1320,12 +1821,10 @@ impl Codegen {
                 }
             }
             Statement::Continue { .. } => {
-                let snippet = self.loop_stack.last().map(|(label, update)| {
-                    (
-                        label.clone(),
-                        update.clone(),
-                    )
-                });
+                let snippet = self
+                    .loop_stack
+                    .last()
+                    .map(|(label, update)| (label.clone(), update.clone()));
                 if let Some((label, Some(update))) = snippet {
                     self.writeln(&update);
                     self.writeln(&format!("continue {};", label));
@@ -1341,7 +1840,15 @@ impl Codegen {
                     span: None,
                 });
             }
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 let e = self.emit_expr(expr)?;
                 self.writeln(&format!("let _sv = {};", e));
                 self.writeln("match () {");
@@ -1389,10 +1896,17 @@ impl Codegen {
             }
             Statement::Throw { value, .. } => {
                 let v = self.emit_expr(value)?;
-                self.writeln(&format!(
-                    "return Err(Box::new(tishlang_runtime::TishError::Throw({})) as Box<dyn std::error::Error>);",
-                    v
-                ));
+                if self.value_fn_depth > 0 {
+                    self.writeln(&format!(
+                        "{{ let _th = {}; panic!(\"uncaught throw: {{}}\", _th.to_display_string()); }}",
+                        v
+                    ));
+                } else {
+                    self.writeln(&format!(
+                        "return Err(Box::new(tishlang_runtime::TishError::Throw({})) as Box<dyn std::error::Error>);",
+                        v
+                    ));
+                }
             }
             Statement::Try {
                 body,
@@ -1407,7 +1921,7 @@ impl Codegen {
                 self.writeln("Ok(Value::Null)");
                 self.indent -= 1;
                 self.writeln("})();");
-                
+
                 if let Some(catch_stmt) = catch_body {
                     if let Some(param) = catch_param {
                         self.writeln("if let Err(e) = _try_result {");
@@ -1417,12 +1931,27 @@ impl Codegen {
                         self.writeln("Ok(tish_err) => {");
                         self.indent += 1;
                         self.writeln("if let tishlang_runtime::TishError::Throw(v) = *tish_err {");
-                        self.writeln(&format!("let {} = v.clone();", Self::escape_ident(param.as_ref())));
+                        self.writeln(&format!(
+                            "let {} = v.clone();",
+                            Self::escape_ident(param.as_ref())
+                        ));
                         self.emit_statement(catch_stmt)?;
-                        self.writeln("} else { return Err(Box::new(tish_err)); }");
+                        if self.value_fn_depth > 0 {
+                            self.writeln(
+                                "} else { panic!(\"unhandled error in native Tish: {:?}\", *tish_err); }",
+                            );
+                        } else {
+                            self.writeln("} else { return Err(Box::new(tish_err)); }");
+                        }
                         self.indent -= 1;
                         self.writeln("}");
-                        self.writeln("Err(orig) => return Err(orig),");
+                        if self.value_fn_depth > 0 {
+                            self.writeln(
+                                "Err(orig) => panic!(\"non-Tish error in native Tish: {:?}\", orig),",
+                            );
+                        } else {
+                            self.writeln("Err(orig) => return Err(orig),");
+                        }
                         self.indent -= 1;
                         self.writeln("}");
                         self.indent -= 1;
@@ -1434,25 +1963,36 @@ impl Codegen {
                     }
                     self.writeln("}");
                 }
-                
+
                 if let Some(finally_stmt) = finally_body {
                     self.emit_statement(finally_stmt)?;
                 }
             }
-            Statement::FunDecl { name, params, rest_param, body, span, .. } => {
+            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();
                 let name_str = Self::escape_ident(name_raw);
                 // Check if cell was already created by block prescan
-                let cell_exists = self.function_scope_stack
+                let cell_exists = self
+                    .function_scope_stack
                     .last()
                     .map(|scope| scope.contains(&name_raw.to_string()))
                     .unwrap_or(false);
                 if !cell_exists {
-                    self.writeln(&format!("let {}_cell: Rc<RefCell<Value>> = Rc::new(RefCell::new(Value::Null));", name_str));
+                    self.writeln(&format!(
+                        "let {}_cell: VmRef<Value> = VmRef::new(Value::Null);",
+                        name_str
+                    ));
                 }
-                
+
                 // Analyze body to find which identifiers are actually referenced
                 let mut referenced = HashSet::new();
                 Self::collect_stmt_idents(body, &mut referenced);
@@ -1461,9 +2001,10 @@ impl Codegen {
                     .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
+                let outer_params: Vec<String> = self
+                    .outer_params_stack
                     .iter()
                     .flat_map(|p| p.iter().cloned())
                     .filter(|name| referenced.contains(name) && !param_names.contains(name))
@@ -1472,11 +2013,34 @@ impl Codegen {
                 // Exclude params and variables declared in this function's body (locals)
                 let mut local_var_names = HashSet::new();
                 Self::collect_local_var_names(body, &mut local_var_names);
-                let outer_vars: Vec<String> = self.outer_vars_stack
+                let outer_vars: Vec<String> = self
+                    .outer_vars_stack
                     .iter()
                     .flat_map(|v| v.iter().cloned())
-                    .filter(|name| referenced.contains(name) && !param_names.contains(name) && !local_var_names.contains(name))
-                    .filter(|name| !["Boolean", "console", "Math", "JSON", "Date", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"].contains(&name.as_str()))
+                    .filter(|name| {
+                        referenced.contains(name)
+                            && !param_names.contains(name)
+                            && !local_var_names.contains(name)
+                    })
+                    .filter(|name| {
+                        ![
+                            "Boolean",
+                            "console",
+                            "Math",
+                            "JSON",
+                            "Date",
+                            "Object",
+                            "process",
+                            "setTimeout",
+                            "clearTimeout",
+                            "setInterval",
+                            "clearInterval",
+                            "Promise",
+                            "RegExp",
+                            "Polars",
+                        ]
+                        .contains(&name.as_str())
+                    })
                     .collect();
 
                 // Outer vars that are assigned in the body need RefCell (capture cell, add to refcell_wrapped_vars).
@@ -1499,9 +2063,15 @@ impl Codegen {
                 for outer_var in &outer_vars {
                     let var_escaped = Self::escape_ident(outer_var);
                     if self.rc_cell_storage_contains(outer_var) {
-                        self.writeln(&format!("let {}_cell = {}.clone();", var_escaped, var_escaped));
+                        self.writeln(&format!(
+                            "let {}_cell = {}.clone();",
+                            var_escaped, var_escaped
+                        ));
                     } else {
-                        self.writeln(&format!("let {}_cell = std::rc::Rc::new(RefCell::new({}.clone()));", var_escaped, var_escaped));
+                        self.writeln(&format!(
+                            "let {}_cell = VmRef::new({}.clone());",
+                            var_escaped, var_escaped
+                        ));
                     }
                 }
 
@@ -1510,57 +2080,119 @@ impl Codegen {
                 // Clone RefCell for outer vars so closure can capture
                 for outer_var in &outer_vars {
                     let var_escaped = Self::escape_ident(outer_var);
-                    self.writeln(&format!("let {}_cell = {}_cell.clone();", var_escaped, var_escaped));
+                    self.writeln(&format!(
+                        "let {}_cell = {}_cell.clone();",
+                        var_escaped, var_escaped
+                    ));
                 }
                 // Clone the cell so the closure can reference the function recursively
                 let needs_self_ref = referenced.contains(name_raw);
                 if needs_self_ref {
-                    self.writeln(&format!("let {}_ref = {}_cell.clone();", name_str, name_str));
+                    self.writeln(&format!(
+                        "let {}_ref = {}_cell.clone();",
+                        name_str, name_str
+                    ));
                 }
                 // Clone sibling function cells for mutual recursion
-                let sibling_fns: Vec<String> = self.function_scope_stack
+                let sibling_fns: Vec<String> = self
+                    .function_scope_stack
                     .last()
-                    .map(|scope| scope.iter()
-                        .filter(|s| s.as_str() != name_raw && referenced.contains(s.as_str()))
-                        .cloned()
-                        .collect())
+                    .map(|scope| {
+                        scope
+                            .iter()
+                            .filter(|s| s.as_str() != name_raw && referenced.contains(s.as_str()))
+                            .cloned()
+                            .collect()
+                    })
                     .unwrap_or_default();
                 for sibling in &sibling_fns {
                     let sibling_escaped = Self::escape_ident(sibling);
-                    self.writeln(&format!("let {}_ref = {}_cell.clone();", sibling_escaped, sibling_escaped));
+                    self.writeln(&format!(
+                        "let {}_ref = {}_cell.clone();",
+                        sibling_escaped, sibling_escaped
+                    ));
                 }
                 // Clone outer parameters so they can be captured by the move closure
                 for outer_param in &outer_params {
                     let param_escaped = Self::escape_ident(outer_param);
-                    self.writeln(&format!("let {} = {}.clone();", param_escaped, param_escaped));
+                    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", "Uint8Array", "AudioContext", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
+                for builtin in &[
+                    "Boolean",
+                    "console",
+                    "Math",
+                    "JSON",
+                    "Date",
+                    "Object",
+                    "Uint8Array",
+                    "AudioContext",
+                    "process",
+                    "setTimeout",
+                    "clearTimeout",
+                    "setInterval",
+                    "clearInterval",
+                    "Promise",
+                    "RegExp",
+                    "Polars",
+                    // Free-standing global functions used inside user-defined
+                    // functions also need to be cloned into the closure
+                    // capture, or the emitted Rust hits E0382 (moved value)
+                    // at the closure's defining `let`.
+                    "parseInt",
+                    "parseFloat",
+                    "isNaN",
+                    "isFinite",
+                    "encodeURI",
+                    "decodeURI",
+                    "htmlEscape",
+                    "registerStaticRoute",
+                    "String",
+                    "Infinity",
+                    "NaN",
+                    "serve",
+                ] {
                     if referenced.contains(*builtin) {
                         self.writeln(&format!("let {} = {}.clone();", builtin, builtin));
                     }
                 }
-                self.writeln("Value::Function(Rc::new(move |args: &[Value]| {");
+                self.writeln("Value::native(move |args: &[Value]| {");
+                self.value_fn_depth += 1;
                 self.indent += 1;
                 // Mutable outer vars: capture the RefCell so assignments use borrow_mut
                 for outer_var in &mutable_outer_vars {
                     let var_escaped = Self::escape_ident(outer_var);
-                    self.writeln(&format!("let {} = {}_cell.clone();", var_escaped, var_escaped));
+                    self.writeln(&format!(
+                        "let {} = {}_cell.clone();",
+                        var_escaped, var_escaped
+                    ));
                 }
                 // Read-only outer vars: Value binding from borrow (avoids param-shadow issues)
                 for outer_var in &read_only_outer_vars {
                     let var_escaped = Self::escape_ident(outer_var);
-                    self.writeln(&format!("let {} = (*{}_cell.borrow()).clone();", var_escaped, var_escaped));
+                    self.writeln(&format!(
+                        "let {} = (*{}_cell.borrow()).clone();",
+                        var_escaped, var_escaped
+                    ));
                 }
                 // Make the function available by its name inside the closure (only if recursive)
                 if needs_self_ref {
-                    self.writeln(&format!("let {} = (*{}_ref.borrow()).clone();", name_str, name_str));
+                    self.writeln(&format!(
+                        "let {} = (*{}_ref.borrow()).clone();",
+                        name_str, name_str
+                    ));
                 }
                 // Make sibling functions available for mutual recursion
                 for sibling in &sibling_fns {
                     let sibling_escaped = Self::escape_ident(sibling);
-                    self.writeln(&format!("let {} = (*{}_ref.borrow()).clone();", sibling_escaped, sibling_escaped));
-                }
+                    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()
@@ -1589,58 +2221,88 @@ impl Codegen {
                 }
                 if let Some(rest) = rest_param {
                     self.writeln(&format!(
-                        "let {} = Value::Array(std::rc::Rc::new(RefCell::new(args[{}..].to_vec())));",
+                        "let {} = Value::Array(VmRef::new(args[{}..].to_vec()));",
                         Self::escape_ident(rest.name.as_ref()),
                         params.len()
                     ));
                 }
-                
-                // Push current params to stack for nested functions
-                self.outer_params_stack.push(current_param_names);
-                
-                // Function bodies are sync closures (even Tish async fn) - use block_on for await
-                self.async_context_stack.push(false);
 
-                // Mutable outer vars must be in refcell_wrapped_vars so Assign/CompoundAssign emit borrow_mut
-                let saved_refcell = self.refcell_wrapped_vars.clone();
-                for v in &mutable_outer_vars {
-                    self.refcell_wrapped_vars.insert(v.clone());
-                }
-                
-                // Pre-scan body for nested functions (handles function body as Block)
-                if let Statement::Block { statements, .. } = body.as_ref() {
-                    let nested_func_names = self.prescan_function_decls(statements);
-                    self.function_scope_stack.push(nested_func_names.clone());
-                    // Create cells for nested functions
-                    for func_name in &nested_func_names {
-                        let escaped = Self::escape_ident(func_name);
-                        self.writeln(&format!("let {}_cell: Rc<RefCell<Value>> = Rc::new(RefCell::new(Value::Null));", escaped));
-                    }
-                    for s in statements {
-                        self.emit_statement(s)?;
+                self.type_context
+                    .push_fun_param_scope(params, rest_param.as_ref());
+
+                let fun_body_res: Result<(), CompileError> = (|| -> Result<(), CompileError> {
+                    // Push current params to stack for nested functions
+                    self.outer_params_stack.push(current_param_names);
+
+                    // Function bodies are sync closures (even Tish async fn) - use block_on for await
+                    self.async_context_stack.push(false);
+
+                    // Mutable outer vars must be in refcell_wrapped_vars so Assign/CompoundAssign emit borrow_mut
+                    let saved_refcell = self.refcell_wrapped_vars.clone();
+                    for v in &mutable_outer_vars {
+                        self.refcell_wrapped_vars.insert(v.clone());
                     }
-                    self.function_scope_stack.pop();
-                } else {
-                    self.function_scope_stack.push(Vec::new());
-                    self.emit_statement(body)?;
-                    self.function_scope_stack.pop();
+
+                    // Pre-scan body for nested functions (handles function body as Block)
+                    if let Statement::Block { statements, .. } = body.as_ref() {
+                        let nested_func_names = self.prescan_function_decls(statements);
+                        self.function_scope_stack.push(nested_func_names.clone());
+                        self.outer_vars_stack.push(Vec::new());
+                        self.rc_cell_storage_scopes
+                            .push(std::collections::HashSet::new());
+                        // Create cells for nested functions
+                        for func_name in &nested_func_names {
+                            let escaped = Self::escape_ident(func_name);
+                            self.writeln(&format!(
+                                "let {}_cell: VmRef<Value> = VmRef::new(Value::Null);",
+                                escaped
+                            ));
+                        }
+                        for s in statements {
+                            self.emit_statement(s)?;
+                        }
+                        self.function_scope_stack.pop();
+                        self.outer_vars_stack.pop();
+                        self.rc_cell_storage_scopes.pop();
+                    } else {
+                        self.function_scope_stack.push(Vec::new());
+                        self.outer_vars_stack.push(Vec::new());
+                        self.rc_cell_storage_scopes
+                            .push(std::collections::HashSet::new());
+                        self.emit_statement(body)?;
+                        self.function_scope_stack.pop();
+                        self.outer_vars_stack.pop();
+                        self.rc_cell_storage_scopes.pop();
+                    }
+
+                    self.async_context_stack.pop();
+
+                    // Restore refcell_wrapped_vars (remove mutable outer vars we added)
+                    self.refcell_wrapped_vars = saved_refcell;
+
+                    // Pop params stack
+                    self.outer_params_stack.pop();
+
+                    Ok(())
+                })();
+
+                self.type_context.pop_scope();
+                if let Err(e) = fun_body_res {
+                    self.value_fn_depth = self.value_fn_depth.saturating_sub(1);
+                    return Err(e);
                 }
-                
-                self.async_context_stack.pop();
 
-                // Restore refcell_wrapped_vars (remove mutable outer vars we added)
-                self.refcell_wrapped_vars = saved_refcell;
-                
-                // Pop params stack
-                self.outer_params_stack.pop();
-                
                 self.writeln("Value::Null");
                 self.indent -= 1;
-                self.writeln("}))");
+                self.writeln("})");
+                self.value_fn_depth = self.value_fn_depth.saturating_sub(1);
                 self.indent -= 1;
                 self.writeln("};");
                 // Update the cell with the actual function value
-                self.writeln(&format!("*{}_cell.borrow_mut() = {}.clone();", name_str, name_str));
+                self.writeln(&format!(
+                    "*{}_cell.borrow_mut() = {}.clone();",
+                    name_str, name_str
+                ));
             }
         }
         Ok(())
@@ -1673,7 +2335,10 @@ impl Codegen {
                     }
                 }
             }
-            Ok(format!("{{ let mut _args: Vec<Value> = Vec::new(); {} _args }}", parts.join(" ")))
+            Ok(format!(
+                "{{ let mut _args: Vec<Value> = Vec::new(); {} _args }}",
+                parts.join(" ")
+            ))
         } else {
             let mut emitted = Vec::new();
             for arg in args {
@@ -1695,14 +2360,20 @@ impl Codegen {
         }
     }
 
-    fn emit_destruct_bindings(&mut self, pattern: &DestructPattern, value_expr: &str, mutability: &str, span: Span) -> Result<(), CompileError> {
+    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) => {
                 for (i, elem) in elements.iter().enumerate() {
                     if let Some(el) = elem {
                         match el {
-                            DestructElement::Ident(name) => {
+                            DestructElement::Ident(name, _) => {
                                 self.writeln(&format!(
                                     "{} {} = match &({}) {{ Value::Array(ref _a) => _a.borrow().get({}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
                                     mutability,
@@ -1719,9 +2390,9 @@ impl Codegen {
                                 ));
                                 self.emit_destruct_bindings(nested, &nested_var, mutability, span)?;
                             }
-                            DestructElement::Rest(name) => {
+                            DestructElement::Rest(name, _) => {
                                 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()))) }};",
+                                    "{} {} = match &({}) {{ Value::Array(ref _a) => {{ let _b = _a.borrow(); Value::Array(VmRef::new(_b.iter().skip({}).cloned().collect())) }}, _ => Value::Array(VmRef::new(Vec::new())) }};",
                                     mutability,
                                     Self::escape_ident(name.as_ref()),
                                     value_expr,
@@ -1736,7 +2407,7 @@ impl Codegen {
                 for prop in props {
                     let key = prop.key.as_ref();
                     match &prop.value {
-                        DestructElement::Ident(name) => {
+                        DestructElement::Ident(name, _) => {
                             self.writeln(&format!(
                                 "{} {} = match &({}) {{ Value::Object(ref _o) => _o.borrow().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }};",
                                 mutability,
@@ -1753,7 +2424,7 @@ impl Codegen {
                             ));
                             self.emit_destruct_bindings(nested, &nested_var, mutability, span)?;
                         }
-                        DestructElement::Rest(_) => {
+                        DestructElement::Rest(_, _) => {
                             return Err(CompileError::new(
                                 "Rest in object destructuring not supported",
                                 Some(span),
@@ -1766,6 +2437,47 @@ impl Codegen {
         Ok(())
     }
 
+    /// Like `VarDecl` pushing onto `outer_vars_stack`, so nested `move` closures rebind
+    /// destructured names via `_cell` / `.clone()` instead of moving `Value` multiple times.
+    fn register_destruct_pattern_outer_vars(&mut self, pattern: &DestructPattern) {
+        match pattern {
+            DestructPattern::Array(elements) => {
+                for el in elements.iter().flatten() {
+                    match el {
+                        DestructElement::Ident(name, _) => {
+                            if let Some(scope) = self.outer_vars_stack.last_mut() {
+                                scope.push(name.to_string());
+                            }
+                        }
+                        DestructElement::Pattern(nested) => {
+                            self.register_destruct_pattern_outer_vars(nested);
+                        }
+                        DestructElement::Rest(name, _) => {
+                            if let Some(scope) = self.outer_vars_stack.last_mut() {
+                                scope.push(name.to_string());
+                            }
+                        }
+                    }
+                }
+            }
+            DestructPattern::Object(props) => {
+                for prop in props {
+                    match &prop.value {
+                        DestructElement::Ident(name, _) => {
+                            if let Some(scope) = self.outer_vars_stack.last_mut() {
+                                scope.push(name.to_string());
+                            }
+                        }
+                        DestructElement::Pattern(nested) => {
+                            self.register_destruct_pattern_outer_vars(nested);
+                        }
+                        DestructElement::Rest(_, _) => {}
+                    }
+                }
+            }
+        }
+    }
+
     fn emit_expr(&mut self, expr: &Expr) -> Result<String, CompileError> {
         Ok(match expr {
             Expr::Literal { value, .. } => match value {
@@ -1819,6 +2531,51 @@ impl Codegen {
                 }
             }
             Expr::Call { callee, args, .. } => {
+                // Typed-struct shortcut for `JSON.stringify(typedValue)`.
+                // When the single arg has a known native type that owns a
+                // hand-rolled `_tish_write_json` (struct or `Vec<struct>`),
+                // emit a direct write into a String buffer and skip the
+                // entire `Value::Object` / `Value::Array` allocation
+                // round-trip + the dynamic stringifier walk. Wraps the
+                // result in `Value::String` for the caller, which is what
+                // the existing `JSON.stringify` returned anyway.
+                if let Expr::Member {
+                    object,
+                    prop: MemberProp::Name { name: method_name, .. },
+                    ..
+                } = callee.as_ref()
+                {
+                    if method_name.as_ref() == "stringify"
+                        && matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "JSON")
+                    {
+                        if args.len() == 1 {
+                            if let CallArg::Expr(arg) = &args[0] {
+                                let (arg_code, arg_ty) = self.emit_typed_expr(arg)?;
+                                match &arg_ty {
+                                    crate::types::RustType::Named { .. } => {
+                                        return Ok(format!(
+                                            "{{ let mut _buf = String::with_capacity(128); ({})._tish_write_json(&mut _buf); Value::String(_buf.into()) }}",
+                                            arg_code
+                                        ));
+                                    }
+                                    crate::types::RustType::Vec(inner)
+                                        if matches!(
+                                            inner.as_ref(),
+                                            crate::types::RustType::Named { .. }
+                                        ) =>
+                                    {
+                                        return Ok(format!(
+                                            "{{ let mut _buf = String::with_capacity(256); _buf.push('['); for (i, item) in ({}).iter().enumerate() {{ if i > 0 {{ _buf.push(','); }} item._tish_write_json(&mut _buf); }} _buf.push(']'); Value::String(_buf.into()) }}",
+                                            arg_code
+                                        ));
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+                    }
+                }
+
                 // Compile-time embed: Polars.read_csv("<literal path>") when file exists
                 if let Some(init) = self.native_module_init.get("tish:polars") {
                     let crate_name = match init {
@@ -1834,7 +2591,7 @@ impl Codegen {
                     {
                         if let Expr::Member {
                             object,
-                            prop: MemberProp::Name(ref method_name),
+                            prop: MemberProp::Name { name: ref method_name, .. },
                             ..
                         } = callee.as_ref()
                         {
@@ -1865,7 +2622,12 @@ impl Codegen {
                 }
 
                 // Check for built-in method calls on arrays/strings
-                if let Expr::Member { object, prop: MemberProp::Name(method_name), .. } = callee.as_ref() {
+                if let Expr::Member {
+                    object,
+                    prop: MemberProp::Name { 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() {
@@ -2248,9 +3010,43 @@ impl Codegen {
                 optional,
                 ..
             } => {
+                // Fast path: typed struct member access. If `object` is
+                // a local with `RustType::Named { fields }` and `prop` is
+                // a literal field name of that struct, lower to a direct
+                // Rust field access (`obj.field`), then wrap in
+                // `Value::*` so the caller gets a `Value` as expected.
+                if !optional {
+                    if let (Expr::Ident { name: var_name, .. }, MemberProp::Name { name: prop_name, .. }) =
+                        (object.as_ref(), prop)
+                    {
+                        let var_type = self.type_context.get_type(var_name.as_ref());
+                        if let RustType::Named { fields, .. } = &var_type {
+                            if let Some((_, field_ty)) =
+                                fields.iter().find(|(k, _)| k.as_ref() == prop_name.as_ref())
+                            {
+                                let var_esc = Self::escape_ident(var_name.as_ref()).into_owned();
+                                let access = if self.refcell_wrapped_vars.contains(var_name.as_ref()) {
+                                    format!(
+                                        "(*{}.borrow()).{}.clone()",
+                                        var_esc,
+                                        crate::types::field_ident(prop_name.as_ref())
+                                    )
+                                } else {
+                                    format!(
+                                        "{}.{}",
+                                        var_esc,
+                                        crate::types::field_ident(prop_name.as_ref())
+                                    )
+                                };
+                                // Caller expects a `Value`; wrap.
+                                return Ok(field_ty.to_value_expr(&access));
+                            }
+                        }
+                    }
+                }
                 let obj = self.emit_expr(object)?;
                 let key = match prop {
-                    MemberProp::Name(n) => format!("{:?}", n.as_ref()),
+                    MemberProp::Name { name, .. } => format!("{:?}", name.as_ref()),
                     MemberProp::Expr(e) => {
                         let k = self.emit_expr(e)?;
                         format!("{}.to_display_string()", k)
@@ -2324,7 +3120,7 @@ impl Codegen {
                             }
                         }
                     }
-                    format!("{{ let mut _arr: Vec<Value> = Vec::new(); {} Value::Array(Rc::new(RefCell::new(_arr))) }}", parts.join(" "))
+                    format!("{{ let mut _arr: Vec<Value> = Vec::new(); {} Value::Array(VmRef::new(_arr)) }}", parts.join(" "))
                 } else {
                     let mut els = Vec::new();
                     for elem in elements {
@@ -2343,7 +3139,7 @@ impl Codegen {
                         }
                     }
                     format!(
-                        "Value::Array(Rc::new(RefCell::new(vec![{}])))",
+                        "Value::Array(VmRef::new(vec![{}]))",
                         els.join(", ")
                     )
                 }
@@ -2368,7 +3164,7 @@ impl Codegen {
                             }
                         }
                     }
-                    format!("{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(Rc::new(RefCell::new(_obj))) }}", parts.join(" "))
+                    format!("{{ let mut _obj: ObjectMap = ObjectMap::default(); {} Value::Object(VmRef::new(_obj)) }}", parts.join(" "))
                 } else {
                     let mut parts = Vec::new();
                     for prop in props {
@@ -2382,7 +3178,7 @@ impl Codegen {
                         }
                     }
                     format!(
-                        "Value::Object(Rc::new(RefCell::new(ObjectMap::from([{}]))))",
+                        "Value::Object(VmRef::new(ObjectMap::from([{}])))",
                         parts.join(", ")
                     )
                 }
@@ -2803,9 +3599,12 @@ impl Codegen {
                 format!("Value::String([{}].concat().into())", parts.join(", "))
             }
             Expr::JsxElement { .. } | Expr::JsxFragment { .. } => {
-                tishlang_ui::jsx::emit_jsx_rust(expr, &mut |e| {
-                    self.emit_expr(e).map_err(|ce| ce.message)
-                })
+                let fun_decls = self.program_fun_decl_names.clone();
+                tishlang_ui::jsx::emit_jsx_rust(
+                    expr,
+                    &mut |e| self.emit_expr(e).map_err(|ce| ce.message),
+                    &fun_decls,
+                )
                 .map_err(|m| CompileError::new(m, None))?
             }
             Expr::New { callee, args, .. } => {
@@ -2852,7 +3651,7 @@ impl Codegen {
             }
         })
     }
-    
+
     /// Collect all identifiers referenced in an arrow body
     fn collect_referenced_idents(body: &ArrowBody) -> HashSet<String> {
         let mut idents = HashSet::new();
@@ -2862,10 +3661,12 @@ impl Codegen {
         }
         idents
     }
-    
+
     fn collect_expr_idents(expr: &Expr, idents: &mut HashSet<String>) {
         match expr {
-            Expr::Ident { name, .. } => { idents.insert(name.to_string()); }
+            Expr::Ident { name, .. } => {
+                idents.insert(name.to_string());
+            }
             Expr::Assign { name, value, .. } => {
                 idents.insert(name.to_string());
                 Self::collect_expr_idents(value, idents);
@@ -2879,7 +3680,9 @@ impl Codegen {
                 Self::collect_expr_idents(callee, idents);
                 for arg in args {
                     match arg {
-                        CallArg::Expr(e) | CallArg::Spread(e) => Self::collect_expr_idents(e, idents),
+                        CallArg::Expr(e) | CallArg::Spread(e) => {
+                            Self::collect_expr_idents(e, idents)
+                        }
                     }
                 }
             }
@@ -2887,19 +3690,28 @@ impl Codegen {
                 Self::collect_expr_idents(callee, idents);
                 for arg in args {
                     match arg {
-                        CallArg::Expr(e) | CallArg::Spread(e) => Self::collect_expr_idents(e, idents),
+                        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); }
+                if let MemberProp::Expr(e) = prop {
+                    Self::collect_expr_idents(e, idents);
+                }
             }
             Expr::MemberAssign { object, value, .. } => {
                 Self::collect_expr_idents(object, idents);
                 Self::collect_expr_idents(value, idents);
             }
-            Expr::IndexAssign { object, index, value, .. } => {
+            Expr::IndexAssign {
+                object,
+                index,
+                value,
+                ..
+            } => {
                 Self::collect_expr_idents(object, idents);
                 Self::collect_expr_idents(index, idents);
                 Self::collect_expr_idents(value, idents);
@@ -2908,13 +3720,20 @@ impl Codegen {
                 Self::collect_expr_idents(object, idents);
                 Self::collect_expr_idents(index, idents);
             }
-            Expr::Conditional { cond, then_branch, else_branch, .. } => {
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_expr_idents(cond, idents);
                 Self::collect_expr_idents(then_branch, idents);
                 Self::collect_expr_idents(else_branch, idents);
             }
-            Expr::PostfixInc { name, .. } | Expr::PostfixDec { name, .. } |
-            Expr::PrefixInc { name, .. } | Expr::PrefixDec { name, .. } => {
+            Expr::PostfixInc { name, .. }
+            | Expr::PostfixDec { name, .. }
+            | Expr::PrefixInc { name, .. }
+            | Expr::PrefixDec { name, .. } => {
                 idents.insert(name.to_string());
             }
             Expr::CompoundAssign { name, value, .. } => {
@@ -2928,23 +3747,25 @@ impl Codegen {
             Expr::Array { elements, .. } => {
                 for el in elements {
                     match el {
-                        ArrayElement::Expr(e) | ArrayElement::Spread(e) => Self::collect_expr_idents(e, idents),
+                        ArrayElement::Expr(e) | ArrayElement::Spread(e) => {
+                            Self::collect_expr_idents(e, idents)
+                        }
                     }
                 }
             }
             Expr::Object { props, .. } => {
                 for prop in props {
                     match prop {
-                        ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => Self::collect_expr_idents(e, idents),
+                        ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                            Self::collect_expr_idents(e, idents)
+                        }
                     }
                 }
             }
-            Expr::ArrowFunction { body, .. } => {
-                match body {
-                    ArrowBody::Expr(e) => Self::collect_expr_idents(e, idents),
-                    ArrowBody::Block(s) => Self::collect_stmt_idents(s, idents),
-                }
-            }
+            Expr::ArrowFunction { body, .. } => match body {
+                ArrowBody::Expr(e) => Self::collect_expr_idents(e, idents),
+                ArrowBody::Block(s) => Self::collect_stmt_idents(s, idents),
+            },
             Expr::NullishCoalesce { left, right, .. } => {
                 Self::collect_expr_idents(left, idents);
                 Self::collect_expr_idents(right, idents);
@@ -2952,12 +3773,20 @@ impl Codegen {
             Expr::TypeOf { operand, .. } => Self::collect_expr_idents(operand, idents),
             Expr::Await { operand, .. } => Self::collect_expr_idents(operand, idents),
             Expr::TemplateLiteral { exprs, .. } => {
-                for e in exprs { Self::collect_expr_idents(e, idents); }
+                for e in exprs {
+                    Self::collect_expr_idents(e, idents);
+                }
             }
-            Expr::JsxElement { props, children, .. } => {
+            Expr::JsxElement {
+                props, children, ..
+            } => {
                 for p in props {
                     match p {
-                        tishlang_ast::JsxProp::Attr { value: tishlang_ast::JsxAttrValue::Expr(e), .. } | tishlang_ast::JsxProp::Spread(e) => Self::collect_expr_idents(e, idents),
+                        tishlang_ast::JsxProp::Attr {
+                            value: tishlang_ast::JsxAttrValue::Expr(e),
+                            ..
+                        }
+                        | tishlang_ast::JsxProp::Spread(e) => Self::collect_expr_idents(e, idents),
                         _ => {}
                     }
                 }
@@ -2978,7 +3807,7 @@ impl Codegen {
             Expr::Literal { .. } => {}
         }
     }
-    
+
     /// Collect variable names that are assigned to in a statement/body (target of =, +=, ++, etc).
     fn collect_assigned_idents_in_stmt(stmt: &Statement, names: &mut HashSet<String>) {
         match stmt {
@@ -2989,14 +3818,25 @@ impl Codegen {
                     Self::collect_assigned_idents_in_stmt(s, names);
                 }
             }
-            Statement::If { cond, then_branch, else_branch, .. } => {
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_expr(cond, names);
                 Self::collect_assigned_idents_in_stmt(then_branch, names);
                 if let Some(eb) = else_branch {
                     Self::collect_assigned_idents_in_stmt(eb, names);
                 }
             }
-            Statement::For { init, cond, update, body, .. } => {
+            Statement::For {
+                init,
+                cond,
+                update,
+                body,
+                ..
+            } => {
                 if let Some(i) = init {
                     Self::collect_assigned_idents_in_stmt(i, names);
                 }
@@ -3016,7 +3856,12 @@ impl Codegen {
                 Self::collect_assigned_idents_in_expr(cond, names);
                 Self::collect_assigned_idents_in_stmt(body, names);
             }
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_expr(expr, names);
                 for (case_expr, stmts) in cases {
                     if let Some(e) = case_expr {
@@ -3032,7 +3877,12 @@ impl Codegen {
                     }
                 }
             }
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_stmt(body, names);
                 if let Some(c) = catch_body {
                     Self::collect_assigned_idents_in_stmt(c, names);
@@ -3048,7 +3898,13 @@ impl Codegen {
                 }
             }
             Statement::Throw { value, .. } => Self::collect_assigned_idents_in_expr(value, names),
-            Statement::Break { .. } | Statement::Continue { .. } | Statement::Import { .. } | Statement::Export { .. } => {}
+            Statement::Break { .. }
+            | Statement::Continue { .. }
+            | Statement::Import { .. }
+            | Statement::Export { .. }
+            | Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
         }
     }
 
@@ -3066,15 +3922,22 @@ impl Codegen {
                 names.insert(name.to_string());
                 Self::collect_assigned_idents_in_expr(value, names);
             }
-            Expr::PostfixInc { name, .. } | Expr::PostfixDec { name, .. }
-            | Expr::PrefixInc { name, .. } | Expr::PrefixDec { name, .. } => {
+            Expr::PostfixInc { name, .. }
+            | Expr::PostfixDec { name, .. }
+            | Expr::PrefixInc { name, .. }
+            | Expr::PrefixDec { name, .. } => {
                 names.insert(name.to_string());
             }
             Expr::MemberAssign { object, value, .. } => {
                 Self::collect_assigned_idents_in_expr(object, names);
                 Self::collect_assigned_idents_in_expr(value, names);
             }
-            Expr::IndexAssign { object, index, value, .. } => {
+            Expr::IndexAssign {
+                object,
+                index,
+                value,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_expr(object, names);
                 Self::collect_assigned_idents_in_expr(index, names);
                 Self::collect_assigned_idents_in_expr(value, names);
@@ -3114,17 +3977,20 @@ impl Codegen {
                 Self::collect_assigned_idents_in_expr(object, names);
                 Self::collect_assigned_idents_in_expr(index, names);
             }
-            Expr::Conditional { cond, then_branch, else_branch, .. } => {
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_expr(cond, names);
                 Self::collect_assigned_idents_in_expr(then_branch, names);
                 Self::collect_assigned_idents_in_expr(else_branch, names);
             }
-            Expr::ArrowFunction { body, .. } => {
-                match body {
-                    ArrowBody::Expr(e) => Self::collect_assigned_idents_in_expr(e, names),
-                    ArrowBody::Block(s) => Self::collect_assigned_idents_in_stmt(s, names),
-                }
-            }
+            Expr::ArrowFunction { body, .. } => match body {
+                ArrowBody::Expr(e) => Self::collect_assigned_idents_in_expr(e, names),
+                ArrowBody::Block(s) => Self::collect_assigned_idents_in_stmt(s, names),
+            },
             Expr::Array { elements, .. } => {
                 for el in elements {
                     match el {
@@ -3152,7 +4018,9 @@ impl Codegen {
                     Self::collect_assigned_idents_in_expr(e, names);
                 }
             }
-            Expr::JsxElement { props, children, .. } => {
+            Expr::JsxElement {
+                props, children, ..
+            } => {
                 for p in props {
                     match p {
                         tishlang_ast::JsxProp::Attr {
@@ -3196,10 +4064,7 @@ impl Codegen {
                 Statement::VarDeclDestructure { pattern, .. } => {
                     Self::collect_destruct_names(pattern, names);
                 }
-                Statement::For {
-                    init: Some(i),
-                    ..
-                } => {
+                Statement::For { init: Some(i), .. } => {
                     if let Statement::VarDecl { name, .. } = i.as_ref() {
                         names.insert(name.to_string());
                     }
@@ -3288,11 +4153,17 @@ impl Codegen {
         }
         match body {
             ArrowBody::Expr(e) => Self::collect_mutated_captures_from_expr(e, block_vars, result),
-            ArrowBody::Block(s) => Self::collect_mutated_captures_from_statements(s, block_vars, result),
+            ArrowBody::Block(s) => {
+                Self::collect_mutated_captures_from_statements(s, block_vars, result)
+            }
         }
     }
 
-    fn collect_mutated_captures_from_expr(expr: &Expr, block_vars: &HashSet<String>, result: &mut HashSet<String>) {
+    fn collect_mutated_captures_from_expr(
+        expr: &Expr,
+        block_vars: &HashSet<String>,
+        result: &mut HashSet<String>,
+    ) {
         match expr {
             Expr::ArrowFunction { params, body, .. } => {
                 Self::collect_mutated_captures_from_arrow(params, body, block_vars, result);
@@ -3323,13 +4194,17 @@ impl Codegen {
                     Self::collect_mutated_captures_from_expr(e, block_vars, result);
                 }
             }
-            Expr::Conditional { cond, then_branch, else_branch, .. } => {
+            Expr::Conditional {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_mutated_captures_from_expr(cond, block_vars, result);
                 Self::collect_mutated_captures_from_expr(then_branch, block_vars, result);
                 Self::collect_mutated_captures_from_expr(else_branch, block_vars, result);
             }
-            Expr::Binary { left, right, .. }
-            | Expr::NullishCoalesce { left, right, .. } => {
+            Expr::Binary { left, right, .. } | Expr::NullishCoalesce { left, right, .. } => {
                 Self::collect_mutated_captures_from_expr(left, block_vars, result);
                 Self::collect_mutated_captures_from_expr(right, block_vars, result);
             }
@@ -3372,14 +4247,25 @@ impl Codegen {
                     Self::collect_mutated_captures_from_statements(s, block_vars, result);
                 }
             }
-            Statement::If { cond, then_branch, else_branch, .. } => {
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_mutated_captures_from_expr(cond, block_vars, result);
                 Self::collect_mutated_captures_from_statements(then_branch, block_vars, result);
                 if let Some(eb) = else_branch {
                     Self::collect_mutated_captures_from_statements(eb, block_vars, result);
                 }
             }
-            Statement::For { init, cond, update, body, .. } => {
+            Statement::For {
+                init,
+                cond,
+                update,
+                body,
+                ..
+            } => {
                 if let Some(i) = init {
                     Self::collect_mutated_captures_from_statements(i, block_vars, result);
                 }
@@ -3399,7 +4285,12 @@ impl Codegen {
                 Self::collect_mutated_captures_from_expr(cond, block_vars, result);
                 Self::collect_mutated_captures_from_statements(body, block_vars, result);
             }
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 Self::collect_mutated_captures_from_expr(expr, block_vars, result);
                 for (ce, stmts) in cases {
                     if let Some(e) = ce {
@@ -3415,7 +4306,12 @@ impl Codegen {
                     }
                 }
             }
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 Self::collect_mutated_captures_from_statements(body, block_vars, result);
                 if let Some(c) = catch_body {
                     Self::collect_mutated_captures_from_statements(c, block_vars, result);
@@ -3433,7 +4329,9 @@ impl Codegen {
             Statement::Return { value: Some(e), .. } => {
                 Self::collect_mutated_captures_from_expr(e, block_vars, result);
             }
-            Statement::Throw { value, .. } => Self::collect_mutated_captures_from_expr(value, block_vars, result),
+            Statement::Throw { value, .. } => {
+                Self::collect_mutated_captures_from_expr(value, block_vars, result)
+            }
             _ => {}
         }
     }
@@ -3452,37 +4350,66 @@ impl Codegen {
     /// Collect variable names declared in a statement (VarDecl, Destructure, For init).
     fn collect_local_var_names(stmt: &Statement, names: &mut HashSet<String>) {
         match stmt {
-            Statement::VarDecl { name, .. } => { names.insert(name.to_string()); }
+            Statement::VarDecl { name, .. } => {
+                names.insert(name.to_string());
+            }
             Statement::VarDeclDestructure { pattern, .. } => {
                 Self::collect_destruct_names(pattern, names);
             }
             Statement::Block { statements, .. } => {
-                for s in statements { Self::collect_local_var_names(s, names); }
+                for s in statements {
+                    Self::collect_local_var_names(s, names);
+                }
             }
-            Statement::If { then_branch, else_branch, .. } => {
+            Statement::If {
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_local_var_names(then_branch, names);
-                if let Some(eb) = else_branch { Self::collect_local_var_names(eb, names); }
+                if let Some(eb) = else_branch {
+                    Self::collect_local_var_names(eb, names);
+                }
             }
             Statement::For { init, body, .. } => {
-                if let Some(i) = init { Self::collect_local_var_names(i, names); }
+                if let Some(i) = init {
+                    Self::collect_local_var_names(i, names);
+                }
                 Self::collect_local_var_names(body, names);
             }
             Statement::ForOf { body, .. } => Self::collect_local_var_names(body, names),
             Statement::While { body, .. } | Statement::DoWhile { body, .. } => {
                 Self::collect_local_var_names(body, names);
             }
-            Statement::Switch { cases, default_body, .. } => {
+            Statement::Switch {
+                cases,
+                default_body,
+                ..
+            } => {
                 for (_, stmts) in cases {
-                    for s in stmts { Self::collect_local_var_names(s, names); }
+                    for s in stmts {
+                        Self::collect_local_var_names(s, names);
+                    }
                 }
                 if let Some(stmts) = default_body {
-                    for s in stmts { Self::collect_local_var_names(s, names); }
+                    for s in stmts {
+                        Self::collect_local_var_names(s, names);
+                    }
                 }
             }
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 Self::collect_local_var_names(body, names);
-                if let Some(c) = catch_body { Self::collect_local_var_names(c, names); }
-                if let Some(f) = finally_body { Self::collect_local_var_names(f, names); }
+                if let Some(c) = catch_body {
+                    Self::collect_local_var_names(c, names);
+                }
+                if let Some(f) = finally_body {
+                    Self::collect_local_var_names(f, names);
+                }
             }
             Statement::FunDecl { body, .. } => Self::collect_local_var_names(body, names),
             _ => {}
@@ -3493,16 +4420,24 @@ impl Codegen {
         match pattern {
             DestructPattern::Array(elements) => {
                 for el in elements {
-                    if let Some(DestructElement::Ident(n)) = el { names.insert(n.to_string()); }
-                    if let Some(DestructElement::Pattern(p)) = el { Self::collect_destruct_names(p, names); }
+                    if let Some(DestructElement::Ident(n, _)) = el {
+                        names.insert(n.to_string());
+                    }
+                    if let Some(DestructElement::Pattern(p)) = el {
+                        Self::collect_destruct_names(p, names);
+                    }
                 }
             }
             DestructPattern::Object(props) => {
                 for prop in props {
                     match &prop.value {
-                        DestructElement::Ident(n) => { names.insert(n.to_string()); }
+                        DestructElement::Ident(n, _) => {
+                            names.insert(n.to_string());
+                        }
                         DestructElement::Pattern(p) => Self::collect_destruct_names(p, names),
-                        DestructElement::Rest(n) => { names.insert(n.to_string()); }
+                        DestructElement::Rest(n, _) => {
+                            names.insert(n.to_string());
+                        }
                     }
                 }
             }
@@ -3513,25 +4448,48 @@ impl Codegen {
         match stmt {
             Statement::ExprStmt { expr, .. } => Self::collect_expr_idents(expr, idents),
             Statement::VarDecl { init, .. } => {
-                if let Some(e) = init { Self::collect_expr_idents(e, idents); }
+                if let Some(e) = init {
+                    Self::collect_expr_idents(e, idents);
+                }
             }
             Statement::VarDeclDestructure { init, .. } => Self::collect_expr_idents(init, idents),
             Statement::Block { statements, .. } => {
-                for s in statements { Self::collect_stmt_idents(s, idents); }
+                for s in statements {
+                    Self::collect_stmt_idents(s, idents);
+                }
             }
-            Statement::If { cond, then_branch, else_branch, .. } => {
+            Statement::If {
+                cond,
+                then_branch,
+                else_branch,
+                ..
+            } => {
                 Self::collect_expr_idents(cond, idents);
                 Self::collect_stmt_idents(then_branch, idents);
-                if let Some(e) = else_branch { Self::collect_stmt_idents(e, idents); }
+                if let Some(e) = else_branch {
+                    Self::collect_stmt_idents(e, idents);
+                }
             }
             Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
                 Self::collect_expr_idents(cond, idents);
                 Self::collect_stmt_idents(body, idents);
             }
-            Statement::For { init, cond, update, body, .. } => {
-                if let Some(s) = init { Self::collect_stmt_idents(s, idents); }
-                if let Some(e) = cond { Self::collect_expr_idents(e, idents); }
-                if let Some(e) = update { Self::collect_expr_idents(e, idents); }
+            Statement::For {
+                init,
+                cond,
+                update,
+                body,
+                ..
+            } => {
+                if let Some(s) = init {
+                    Self::collect_stmt_idents(s, idents);
+                }
+                if let Some(e) = cond {
+                    Self::collect_expr_idents(e, idents);
+                }
+                if let Some(e) = update {
+                    Self::collect_expr_idents(e, idents);
+                }
                 Self::collect_stmt_idents(body, idents);
             }
             Statement::ForOf { iterable, body, .. } => {
@@ -3539,26 +4497,54 @@ impl Codegen {
                 Self::collect_stmt_idents(body, idents);
             }
             Statement::Return { value, .. } => {
-                if let Some(e) = value { Self::collect_expr_idents(e, idents); }
+                if let Some(e) = value {
+                    Self::collect_expr_idents(e, idents);
+                }
             }
             Statement::Throw { value, .. } => Self::collect_expr_idents(value, idents),
-            Statement::Try { body, catch_body, finally_body, .. } => {
+            Statement::Try {
+                body,
+                catch_body,
+                finally_body,
+                ..
+            } => {
                 Self::collect_stmt_idents(body, idents);
-                if let Some(c) = catch_body { Self::collect_stmt_idents(c, idents); }
-                if let Some(f) = finally_body { Self::collect_stmt_idents(f, idents); }
+                if let Some(c) = catch_body {
+                    Self::collect_stmt_idents(c, idents);
+                }
+                if let Some(f) = finally_body {
+                    Self::collect_stmt_idents(f, idents);
+                }
             }
-            Statement::Switch { expr, cases, default_body, .. } => {
+            Statement::Switch {
+                expr,
+                cases,
+                default_body,
+                ..
+            } => {
                 Self::collect_expr_idents(expr, idents);
                 for (case_expr, stmts) in cases {
-                    if let Some(e) = case_expr { Self::collect_expr_idents(e, idents); }
-                    for s in stmts { Self::collect_stmt_idents(s, idents); }
+                    if let Some(e) = case_expr {
+                        Self::collect_expr_idents(e, idents);
+                    }
+                    for s in stmts {
+                        Self::collect_stmt_idents(s, idents);
+                    }
                 }
                 if let Some(stmts) = default_body {
-                    for s in stmts { Self::collect_stmt_idents(s, idents); }
+                    for s in stmts {
+                        Self::collect_stmt_idents(s, idents);
+                    }
                 }
             }
             Statement::FunDecl { body, .. } => Self::collect_stmt_idents(body, idents),
-            Statement::Break { .. } | Statement::Continue { .. } | Statement::Import { .. } | Statement::Export { .. } => {}
+            Statement::Break { .. }
+            | Statement::Continue { .. }
+            | Statement::Import { .. }
+            | Statement::Export { .. }
+            | Statement::TypeAlias { .. }
+            | Statement::DeclareVar { .. }
+            | Statement::DeclareFun { .. } => {}
         }
     }
 
@@ -3571,7 +4557,7 @@ impl Codegen {
         // Build the arrow function as a Value::Function closure
         let mut code = String::new();
         code.push_str("{\n");
-        
+
         // 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
@@ -3589,17 +4575,42 @@ impl Codegen {
         }
 
         // Collect outer parameters that need to be captured
-        let outer_params: Vec<String> = self.outer_params_stack
+        let outer_params: Vec<String> = self
+            .outer_params_stack
             .iter()
             .flat_map(|p| p.iter().cloned())
             .filter(|name| referenced.contains(name) && !param_names.contains(name))
             .collect();
-        
+
         // Collect outer variables (from outer scopes) that need to be captured
-        let outer_vars: Vec<String> = self.outer_vars_stack
+        let outer_vars: Vec<String> = self
+            .outer_vars_stack
             .iter()
             .flat_map(|v| v.iter().cloned())
-            .filter(|name| referenced.contains(name) && !param_names.contains(name) && !local_var_names.contains(name))
+            .filter(|name| {
+                referenced.contains(name)
+                    && !param_names.contains(name)
+                    && !local_var_names.contains(name)
+            })
+            .filter(|name| {
+                ![
+                    "Boolean",
+                    "console",
+                    "Math",
+                    "JSON",
+                    "Date",
+                    "Object",
+                    "process",
+                    "setTimeout",
+                    "clearTimeout",
+                    "setInterval",
+                    "clearInterval",
+                    "Promise",
+                    "RegExp",
+                    "Polars",
+                ]
+                .contains(&name.as_str())
+            })
             .collect();
 
         // Outer vars that are assigned in the body need RefCell; read-only get Value binding
@@ -3608,8 +4619,18 @@ impl Codegen {
             ArrowBody::Expr(e) => Self::collect_assigned_idents_in_expr(e, &mut assigned_in_body),
             ArrowBody::Block(s) => Self::collect_assigned_idents_in_stmt(s, &mut assigned_in_body),
         }
-        let mutable_outer_vars: Vec<String> = outer_vars.iter().filter(|v| assigned_in_body.contains(*v)).cloned().collect();
-        let read_only_outer_vars: Vec<String> = outer_vars.iter().filter(|v| !assigned_in_body.contains(*v)).cloned().collect();
+        // Live cell capture: assigned here, or already `Rc<RefCell<Value>>` in a parent scope
+        // (cleanups may only read `timer2` but must see updates from nested callbacks).
+        let cell_capture_outer_vars: Vec<String> = outer_vars
+            .iter()
+            .filter(|v| assigned_in_body.contains(*v) || self.rc_cell_storage_contains(*v))
+            .cloned()
+            .collect();
+        let read_only_outer_vars: Vec<String> = outer_vars
+            .iter()
+            .filter(|v| !assigned_in_body.contains(*v) && !self.rc_cell_storage_contains(*v))
+            .cloned()
+            .collect();
 
         // Wrap outer captures in Rc<RefCell<>> and use _ref suffix.
         // Clone existing Rc only when VarDecl actually emitted `Rc<RefCell<...>>` (see rc_cell_storage_*).
@@ -3617,62 +4638,110 @@ impl Codegen {
             let param_escaped = Self::escape_ident(outer_param);
             let ref_name = format!("{}_ref", param_escaped);
             if self.rc_cell_storage_contains(outer_param) {
-                code.push_str(&format!("    let {} = {}.clone();\n", ref_name, param_escaped));
+                code.push_str(&format!(
+                    "    let {} = {}.clone();\n",
+                    ref_name, param_escaped
+                ));
             } else {
-                code.push_str(&format!("    let {} = std::rc::Rc::new(RefCell::new({}.clone()));\n", ref_name, param_escaped));
+                code.push_str(&format!(
+                    "    let {} = VmRef::new({}.clone());\n",
+                    ref_name, param_escaped
+                ));
             }
         }
         for outer_var in &outer_vars {
             let var_escaped = Self::escape_ident(outer_var);
             let ref_name = format!("{}_ref", var_escaped);
             if self.rc_cell_storage_contains(outer_var) {
-                code.push_str(&format!("    let {} = {}.clone();\n", ref_name, var_escaped));
+                code.push_str(&format!(
+                    "    let {} = {}.clone();\n",
+                    ref_name, var_escaped
+                ));
             } else {
-                code.push_str(&format!("    let {} = std::rc::Rc::new(RefCell::new({}.clone()));\n", ref_name, var_escaped));
+                code.push_str(&format!(
+                    "    let {} = VmRef::new({}.clone());\n",
+                    ref_name, var_escaped
+                ));
             }
         }
         // 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", "Uint8Array", "AudioContext", "process", "setTimeout", "clearTimeout", "Promise", "RegExp", "Polars"] {
+        for builtin in &[
+            "console",
+            "Math",
+            "JSON",
+            "Date",
+            "Object",
+            "Uint8Array",
+            "AudioContext",
+            "process",
+            "setTimeout",
+            "clearTimeout",
+            "setInterval",
+            "clearInterval",
+            "Promise",
+            "RegExp",
+            "Polars",
+        ] {
             if referenced.contains(*builtin) {
                 code.push_str(&format!("    let {} = {}.clone();\n", builtin, builtin));
             }
         }
 
         // Clone only function cells that are actually referenced in this arrow
-        let referenced_funcs: Vec<String> = self.function_scope_stack
+        let referenced_funcs: Vec<String> = self
+            .function_scope_stack
             .last()
-            .map(|scope| scope.iter()
-                .filter(|f| referenced.contains(f.as_str()) && !param_names.contains(*f))
-                .cloned()
-                .collect())
+            .map(|scope| {
+                scope
+                    .iter()
+                    .filter(|f| referenced.contains(f.as_str()) && !param_names.contains(*f))
+                    .cloned()
+                    .collect()
+            })
             .unwrap_or_default();
         for func_name in &referenced_funcs {
             let escaped = Self::escape_ident(func_name);
-            code.push_str(&format!("    let {}_ref = {}_cell.clone();\n", escaped, escaped));
+            code.push_str(&format!(
+                "    let {}_ref = {}_cell.clone();\n",
+                escaped, escaped
+            ));
         }
 
-        code.push_str("    Value::Function(Rc::new(move |args: &[Value]| {\n");
+        code.push_str("    Value::native(move |args: &[Value]| {\n");
+        self.value_fn_depth += 1;
 
         // Make captured outer params available as plain Values (from _ref RefCells)
         for outer_param in &outer_params {
             let param_escaped = Self::escape_ident(outer_param);
-            code.push_str(&format!("        let {} = (*{}_ref.borrow()).clone();\n", param_escaped, param_escaped));
+            code.push_str(&format!(
+                "        let {} = (*{}_ref.borrow()).clone();\n",
+                param_escaped, param_escaped
+            ));
         }
-        // Mutable outer vars: capture RefCell so assignments use borrow_mut
-        for outer_var in &mutable_outer_vars {
+        // Outer vars that share a RefCell with the parent: capture the cell (read + write)
+        for outer_var in &cell_capture_outer_vars {
             let var_escaped = Self::escape_ident(outer_var);
-            code.push_str(&format!("        let {} = {}_ref.clone();\n", var_escaped, var_escaped));
+            code.push_str(&format!(
+                "        let {} = {}_ref.clone();\n",
+                var_escaped, var_escaped
+            ));
         }
-        // Read-only outer vars: Value binding from borrow
+        // Read-only outer vars: snapshot Value at closure creation
         for outer_var in &read_only_outer_vars {
             let var_escaped = Self::escape_ident(outer_var);
-            code.push_str(&format!("        let {} = (*{}_ref.borrow()).clone();\n", var_escaped, var_escaped));
+            code.push_str(&format!(
+                "        let {} = (*{}_ref.borrow()).clone();\n",
+                var_escaped, var_escaped
+            ));
         }
 
         // Make captured functions available
         for func_name in &referenced_funcs {
             let escaped = Self::escape_ident(func_name);
-            code.push_str(&format!("        let {} = (*{}_ref.borrow()).clone();\n", escaped, escaped));
+            code.push_str(&format!(
+                "        let {} = (*{}_ref.borrow()).clone();\n",
+                escaped, escaped
+            ));
         }
 
         // Extract parameters from args
@@ -3712,44 +4781,55 @@ impl Codegen {
         // Push empty scope for variables declared inside this arrow function
         self.outer_vars_stack.push(Vec::new());
 
-        // Mutable outer vars need to be in refcell_wrapped_vars so Assign/CompoundAssign emit borrow_mut
+        // Cell-backed outer vars need refcell_wrapped_vars for Assign and for reads in emit_expr
         let saved_refcell_vars = self.refcell_wrapped_vars.clone();
-        for v in &mutable_outer_vars {
+        for v in &cell_capture_outer_vars {
             self.refcell_wrapped_vars.insert(v.clone());
         }
 
-        // Emit body based on type
-        match body {
+        self.type_context.push_fun_param_scope(params, None);
+
+        let arrow_body_res: Result<(), CompileError> = match body {
             tishlang_ast::ArrowBody::Expr(expr) => {
                 let expr_code = self.emit_expr(expr)?;
                 code.push_str(&format!("        {}\n", expr_code));
+                Ok(())
             }
             tishlang_ast::ArrowBody::Block(block_stmt) => {
                 // For block bodies, emit the block statement
                 self.function_scope_stack.push(Vec::new());
-                
+
                 // Save current output, emit to temp, then restore
                 let saved_output = std::mem::take(&mut self.output);
                 let saved_indent = self.indent;
                 self.indent = 2; // Base indent inside the closure
-                
+
                 self.emit_statement(block_stmt)?;
-                
+
                 let body_code = std::mem::replace(&mut self.output, saved_output);
                 self.indent = saved_indent;
                 self.function_scope_stack.pop();
-                
+
                 code.push_str(&body_code);
                 code.push_str("        Value::Null\n");
+                Ok(())
             }
+        };
+
+        self.type_context.pop_scope();
+        if let Err(e) = arrow_body_res {
+            self.value_fn_depth = self.value_fn_depth.saturating_sub(1);
+            return Err(e);
         }
 
+        self.value_fn_depth = self.value_fn_depth.saturating_sub(1);
+
         // Restore state
         self.refcell_wrapped_vars = saved_refcell_vars;
         self.outer_params_stack.pop();
         self.outer_vars_stack.pop();
 
-        code.push_str("    }))\n");
+        code.push_str("    })\n");
         code.push('}');
 
         Ok(code)
@@ -3758,7 +4838,11 @@ impl Codegen {
     /// Emit an expression as a native Rust type (not wrapped in Value).
     /// Falls back to emit_expr + conversion if the expression cannot be directly
     /// emitted as the target type.
-    fn emit_native_expr(&mut self, expr: &Expr, target_type: &RustType) -> Result<String, CompileError> {
+    fn emit_native_expr(
+        &mut self,
+        expr: &Expr,
+        target_type: &RustType,
+    ) -> Result<String, CompileError> {
         // Try to emit literals directly as native types
         if let Expr::Literal { value, .. } = expr {
             match (target_type, value) {
@@ -3777,7 +4861,7 @@ impl Codegen {
                 _ => {}
             }
         }
-        
+
         // Try to emit array literals directly as Vec<T>
         if let (RustType::Vec(inner_type), Expr::Array { elements, .. }) = (target_type, expr) {
             let mut items = Vec::new();
@@ -3796,7 +4880,58 @@ impl Codegen {
             }
             return Ok(format!("vec![{}]", items.join(", ")));
         }
-        
+
+        // Try to emit object literals directly as a Rust struct literal
+        // when the target is a `RustType::Named` (a user `type Foo = {...}`
+        // alias). Each property in source order is matched to a struct
+        // field; missing fields fall back to `default_value()` so the
+        // emit succeeds even on partial literals (rare, but harmless).
+        if let (RustType::Named { name, fields }, Expr::Object { props, .. }) =
+            (target_type, expr)
+        {
+            use std::collections::HashMap;
+            let field_types: HashMap<&str, &RustType> = fields
+                .iter()
+                .map(|(k, t)| (k.as_ref(), t))
+                .collect();
+            let mut field_inits: HashMap<String, String> = HashMap::new();
+            let mut bail = false;
+            for prop in props {
+                match prop {
+                    ObjectProp::KeyValue(key, value) => {
+                        if let Some(field_ty) = field_types.get(key.as_ref()) {
+                            let v = self.emit_native_expr(value, field_ty)?;
+                            field_inits.insert(crate::types::field_ident(key.as_ref()), v);
+                        }
+                    }
+                    // Spread can't be statically matched to struct fields:
+                    // fall back to the dynamic Value path.
+                    ObjectProp::Spread(_) => {
+                        bail = true;
+                        break;
+                    }
+                }
+            }
+            if !bail {
+                let assigns = fields
+                    .iter()
+                    .map(|(k, t)| {
+                        let fid = crate::types::field_ident(k);
+                        match field_inits.remove(&fid) {
+                            Some(v) => format!("{}: {}", fid, v),
+                            None => format!("{}: {}", fid, t.default_value()),
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                return Ok(format!(
+                    "{} {{ {} }}",
+                    crate::types::named_struct_ident(name),
+                    assigns
+                ));
+            }
+        }
+
         // Check if the identifier is already of the target type
         if let Expr::Ident { name, .. } = expr {
             let var_type = self.type_context.get_type(name.as_ref());
@@ -3808,7 +4943,7 @@ impl Codegen {
                 return Ok(esc);
             }
         }
-        
+
         // Fall back to emit_expr + conversion
         let value_expr = self.emit_expr(expr)?;
         Ok(target_type.from_value_expr(&value_expr))
@@ -3829,7 +4964,9 @@ impl Codegen {
             // ── 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::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)),
             },
@@ -3855,7 +4992,13 @@ impl Codegen {
             }
 
             // ── binary expressions ───────────────────────────────────────────────
-            Expr::Binary { left, op, right, span, .. } => {
+            Expr::Binary {
+                left,
+                op,
+                right,
+                span,
+                ..
+            } => {
                 let (l, lt) = self.emit_typed_expr(left)?;
                 let (r, rt) = self.emit_typed_expr(right)?;
 
@@ -3882,14 +5025,27 @@ impl Codegen {
                 }
 
                 // 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 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, .. } => {
+            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() {
@@ -3958,19 +5114,28 @@ impl Codegen {
         }
     }
 
-    fn emit_binop(
-        &self,
-        l: &str,
-        op: BinOp,
-        r: &str,
-        span: Span,
-    ) -> Result<String, CompileError> {
+    fn emit_binop(&self, l: &str, op: BinOp, r: &str, span: Span) -> Result<String, CompileError> {
         Ok(match op {
-            BinOp::Add => format!("tishlang_runtime::ops::add(&{}, &{}).unwrap_or(Value::Null)", l, r),
-            BinOp::Sub => format!("tishlang_runtime::ops::sub(&{}, &{}).unwrap_or(Value::Null)", l, r),
-            BinOp::Mul => format!("tishlang_runtime::ops::mul(&{}, &{}).unwrap_or(Value::Null)", l, r),
-            BinOp::Div => format!("tishlang_runtime::ops::div(&{}, &{}).unwrap_or(Value::Null)", l, r),
-            BinOp::Mod => format!("tishlang_runtime::ops::modulo(&{}, &{}).unwrap_or(Value::Null)", l, r),
+            BinOp::Add => format!(
+                "tishlang_runtime::ops::add(&{}, &{}).unwrap_or(Value::Null)",
+                l, r
+            ),
+            BinOp::Sub => format!(
+                "tishlang_runtime::ops::sub(&{}, &{}).unwrap_or(Value::Null)",
+                l, r
+            ),
+            BinOp::Mul => format!(
+                "tishlang_runtime::ops::mul(&{}, &{}).unwrap_or(Value::Null)",
+                l, r
+            ),
+            BinOp::Div => format!(
+                "tishlang_runtime::ops::div(&{}, &{}).unwrap_or(Value::Null)",
+                l, r
+            ),
+            BinOp::Mod => format!(
+                "tishlang_runtime::ops::modulo(&{}, &{}).unwrap_or(Value::Null)",
+                l, r
+            ),
             BinOp::Pow => format!(
                 "Value::Number({{ let Value::Number(a) = &({}) else {{ panic!() }}; \
                  let Value::Number(b) = &({}) else {{ panic!() }}; a.powf(*b) }})",
@@ -3991,7 +5156,10 @@ impl Codegen {
             BinOp::Shr => Self::emit_bitwise_binop(l, r, ">>"),
             BinOp::In => format!("tish_in_operator(&{}, &{})", l, r),
             BinOp::Eq | BinOp::Ne => {
-                return Err(CompileError::new("Loose equality not supported", Some(span)))
+                return Err(CompileError::new(
+                    "Loose equality not supported",
+                    Some(span),
+                ))
             }
         })
     }