@tishlang/tish 1.0.33 → 1.0.34

package/crates/tish/Cargo.toml

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

package/crates/tish_compile/src/codegen.rs

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

package/crates/tish_compile/src/infer.rs

@@ -0,0 +1,236 @@
+//! Type inference pass: annotates `VarDecl` nodes with inferred `TypeAnnotation`s
+//! where the user hasn't provided them, enabling codegen to emit native Rust types.
+//!
+//! Rules (conservative — only infer when unambiguous):
+//!   - Number literal init           → `number`
+//!   - String literal init           → `string`
+//!   - Bool literal init             → `boolean`
+//!   - Arithmetic of two `number` expressions → `number`
+//!   - Comparison of two `number` expressions → `boolean`
+//!   - Already-annotated vars are left unchanged.
+
+use std::collections::HashMap;
+use tishlang_ast::{
+    ArrowBody, BinOp, CallArg, Expr, FunParam, Literal, Program, Statement, TypeAnnotation,
+};
+
+/// Scoped type environment used during inference.
+#[derive(Default)]
+pub struct InferCtx {
+    scopes: Vec<HashMap<String, TypeAnnotation>>,
+}
+
+impl InferCtx {
+    pub fn new() -> Self {
+        Self { scopes: vec![HashMap::new()] }
+    }
+
+    fn push_scope(&mut self) {
+        self.scopes.push(HashMap::new());
+    }
+
+    fn pop_scope(&mut self) {
+        self.scopes.pop();
+    }
+
+    fn define(&mut self, name: &str, ty: TypeAnnotation) {
+        if let Some(s) = self.scopes.last_mut() {
+            s.insert(name.to_string(), ty);
+        }
+    }
+
+    pub fn lookup(&self, name: &str) -> Option<&TypeAnnotation> {
+        for s in self.scopes.iter().rev() {
+            if let Some(t) = s.get(name) {
+                return Some(t);
+            }
+        }
+        None
+    }
+}
+
+fn is_number(ann: &TypeAnnotation) -> bool {
+    matches!(ann, TypeAnnotation::Simple(s) if s.as_ref() == "number")
+}
+
+fn number_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("number".into())
+}
+
+fn string_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("string".into())
+}
+
+fn bool_ann() -> TypeAnnotation {
+    TypeAnnotation::Simple("boolean".into())
+}
+
+/// Infer the `TypeAnnotation` for an expression, if unambiguous.
+pub fn infer_expr_type(expr: &Expr, ctx: &InferCtx) -> Option<TypeAnnotation> {
+    match expr {
+        Expr::Literal { value, .. } => match value {
+            Literal::Number(_) => Some(number_ann()),
+            Literal::String(_) => Some(string_ann()),
+            Literal::Bool(_) => Some(bool_ann()),
+            Literal::Null => None,
+        },
+        Expr::Ident { name, .. } => ctx.lookup(name.as_ref()).cloned(),
+        Expr::Binary { left, op, right, .. } => {
+            let lt = infer_expr_type(left, ctx)?;
+            let rt = infer_expr_type(right, ctx)?;
+            if is_number(&lt) && is_number(&rt) {
+                match op {
+                    BinOp::Add
+                    | BinOp::Sub
+                    | BinOp::Mul
+                    | BinOp::Div
+                    | BinOp::Mod
+                    | BinOp::Pow => Some(number_ann()),
+                    BinOp::Lt
+                    | BinOp::Le
+                    | BinOp::Gt
+                    | BinOp::Ge
+                    | BinOp::StrictEq
+                    | BinOp::StrictNe => Some(bool_ann()),
+                    _ => None,
+                }
+            } else {
+                None
+            }
+        }
+        Expr::Unary { op, operand, .. } => {
+            use tishlang_ast::UnaryOp;
+            match op {
+                UnaryOp::Neg | UnaryOp::Pos => {
+                    let t = infer_expr_type(operand, ctx)?;
+                    if is_number(&t) { Some(number_ann()) } else { None }
+                }
+                UnaryOp::Not => Some(bool_ann()),
+                _ => None,
+            }
+        }
+        _ => None,
+    }
+}
+
+/// Run inference over a program, returning a modified Program with additional
+/// type annotations filled in on `VarDecl` nodes.
+pub fn infer_program(program: &Program) -> Program {
+    let mut ctx = InferCtx::new();
+    Program { statements: infer_statements(&program.statements, &mut ctx) }
+}
+
+fn infer_statements(stmts: &[Statement], ctx: &mut InferCtx) -> Vec<Statement> {
+    stmts.iter().map(|s| infer_statement(s, ctx)).collect()
+}
+
+fn infer_statement(stmt: &Statement, ctx: &mut InferCtx) -> Statement {
+    match stmt {
+        Statement::VarDecl { name, mutable, type_ann, init, span } => {
+            // Already annotated — propagate into ctx but don't change the node.
+            if let Some(ann) = type_ann {
+                ctx.define(name.as_ref(), ann.clone());
+                return stmt.clone();
+            }
+            // Try to infer from init expression.
+            let inferred = init.as_ref().and_then(|e| infer_expr_type(e, ctx));
+            if let Some(ref ann) = inferred {
+                ctx.define(name.as_ref(), ann.clone());
+            }
+            Statement::VarDecl {
+                name: name.clone(),
+                mutable: *mutable,
+                type_ann: inferred,
+                init: init.clone(),
+                span: *span,
+            }
+        }
+        Statement::Block { statements, span } => {
+            ctx.push_scope();
+            let stmts = infer_statements(statements, ctx);
+            ctx.pop_scope();
+            Statement::Block { statements: stmts, span: *span }
+        }
+        Statement::For { init, cond, update, body, span } => {
+            // Scope for loop variable
+            ctx.push_scope();
+            let new_init = init.as_ref().map(|i| Box::new(infer_statement(i, ctx)));
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::For {
+                init: new_init,
+                cond: cond.clone(),
+                update: update.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        Statement::ForOf { name, iterable, body, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::ForOf {
+                name: name.clone(),
+                iterable: iterable.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        Statement::While { cond, body, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::While { cond: cond.clone(), body: new_body, span: *span }
+        }
+        Statement::DoWhile { body, cond, span } => {
+            ctx.push_scope();
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::DoWhile { body: new_body, cond: cond.clone(), span: *span }
+        }
+        Statement::If { cond, then_branch, else_branch, span } => {
+            let new_then = Box::new(infer_statement(then_branch, ctx));
+            let new_else = else_branch.as_ref().map(|e| Box::new(infer_statement(e, ctx)));
+            Statement::If {
+                cond: cond.clone(),
+                then_branch: new_then,
+                else_branch: new_else,
+                span: *span,
+            }
+        }
+        Statement::FunDecl { async_, name, params, rest_param, return_type, body, span } => {
+            ctx.push_scope();
+            for p in params {
+                if let FunParam::Simple(tp) = p {
+                    if let Some(ann) = &tp.type_ann {
+                        ctx.define(tp.name.as_ref(), ann.clone());
+                    }
+                }
+            }
+            if let Some(rp) = rest_param {
+                if let Some(ann) = &rp.type_ann {
+                    ctx.define(rp.name.as_ref(), ann.clone());
+                }
+            }
+            let new_body = Box::new(infer_statement(body, ctx));
+            ctx.pop_scope();
+            Statement::FunDecl {
+                async_: *async_,
+                name: name.clone(),
+                params: params.clone(),
+                rest_param: rest_param.clone(),
+                return_type: return_type.clone(),
+                body: new_body,
+                span: *span,
+            }
+        }
+        // For statements with no interesting sub-structure, clone as-is.
+        _ => stmt.clone(),
+    }
+}
+
+// Suppress unused import warning — CallArg is used indirectly via tishlang_ast.
+#[allow(dead_code)]
+fn _uses_call_arg(_: &CallArg) {}
+#[allow(dead_code)]
+fn _uses_arrow_body(_: &ArrowBody) {}

package/crates/tish_compile/src/lib.rs

@@ -3,6 +3,7 @@
 //! Emits Rust source that links to tishlang_runtime.
 
 mod codegen;
+mod infer;
 mod resolve;
 mod types;
 
@@ -25,6 +26,9 @@ mod tests {
 
     #[test]
     fn typed_assign_conversion() {
+        // With the inference pass and native emit, `total: number = 0` becomes f64.
+        // Assignment `total = total + n` (where n comes from ForOf over a Value::Array)
+        // emits a native f64 assignment that unboxes the Value result via from_value_expr.
         let src = r#"
 fn sum(...args: number[]): number {
     let total: number = 0
@@ -34,11 +38,16 @@ fn sum(...args: number[]): number {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
-        assert!(rust.contains("match &_v { Value::Number(n) => *n"), "expected typed assign conversion");
+        // total should be declared as f64
+        assert!(rust.contains("let mut total: f64"), "expected total: f64");
+        // The return value of run() should convert total back to Value
+        assert!(rust.contains("Value::Number(total)"), "expected Value::Number(total) wrapping");
     }
 
     #[test]
     fn loop_var_decl_clone_outer_var() {
+        // With inference, outerVar = 42 gets inferred as f64. f64 is Copy, so no clone is
+        // needed — direct assignment is correct. The test verifies compilation succeeds.
         let src = r#"
 let outerVar = 42
 for (let i = 0; i < 5; i = i + 1) {
@@ -47,10 +56,9 @@ for (let i = 0; i < 5; i = i + 1) {
 "#;
         let program = parse(src).unwrap();
         let rust = compile(&program).unwrap();
-        assert!(
-            rust.contains("(outerVar).clone()"),
-            "expected outerVar to be cloned in loop body"
-        );
+        // outerVar and x are f64 (inferred) — Copy assignment, no .clone() needed.
+        assert!(rust.contains("let mut outerVar: f64"), "expected outerVar: f64");
+        assert!(rust.contains("let mut x: f64"), "expected x: f64");
     }
 
     #[test]
@@ -90,6 +98,9 @@ fn factory() {
 
     #[test]
     fn loop_var_decl_clone_via_project_full() {
+        // With the inference pass, `let outerVar = 42` is inferred as f64 (Copy) — no clone needed.
+        // This test verifies the full benchmark_granular project compiles and that outerVar
+        // is emitted as the inferred f64 type rather than requiring a Value clone.
         let manifest = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
         let bench = manifest.join("../../tests/core/benchmark_granular.tish").canonicalize().unwrap();
         // Use same default features as tish CLI (http, fs, process, regex)
@@ -98,9 +109,10 @@ fn factory() {
             .map(String::from)
             .collect::<Vec<_>>();
         let (rust, _) = compile_project_full(&bench, bench.parent(), &features, true).unwrap();
+        // outerVar = 42 is inferred as f64; f64 is Copy so no .clone() is emitted.
         assert!(
-            rust.contains("(outerVar).clone()"),
-            "expected outerVar to be cloned in benchmark_granular loop"
+            rust.contains("let mut outerVar: f64"),
+            "expected outerVar to be inferred as f64 (Copy, no clone needed)"
         );
     }
 }

package/crates/tish_compile/src/types.rs

@@ -4,7 +4,7 @@
 
 use std::collections::HashMap;
 use std::sync::Arc;
-use tishlang_ast::TypeAnnotation;
+use tishlang_ast::{BinOp, TypeAnnotation};
 
 /// Concrete Rust type representation for code generation.
 #[derive(Debug, Clone, PartialEq)]
@@ -89,6 +89,38 @@ impl RustType {
         !matches!(self, RustType::Value)
     }
 
+    /// Check if this type is numeric (f64).
+    pub fn is_numeric(&self) -> bool {
+        matches!(self, RustType::F64)
+    }
+
+    /// Infer the result type of a binary operation given the operand types.
+    /// Returns `None` if native code cannot be emitted (fall back to Value path).
+    pub fn result_type_of_binop(op: BinOp, lhs: &RustType, rhs: &RustType) -> Option<RustType> {
+        if lhs == &RustType::F64 && rhs == &RustType::F64 {
+            match op {
+                BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Mod | BinOp::Pow => {
+                    Some(RustType::F64)
+                }
+                BinOp::Lt
+                | BinOp::Le
+                | BinOp::Gt
+                | BinOp::Ge
+                | BinOp::StrictEq
+                | BinOp::StrictNe => Some(RustType::Bool),
+                _ => None,
+            }
+        } else if lhs == &RustType::Bool && rhs == &RustType::Bool {
+            match op {
+                BinOp::And | BinOp::Or => Some(RustType::Bool),
+                BinOp::StrictEq | BinOp::StrictNe => Some(RustType::Bool),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    }
+
     /// Get the Rust type string for code generation.
     pub fn to_rust_type_str(&self) -> String {
         match self {
@@ -169,14 +201,19 @@ impl RustType {
         match self {
             RustType::Value => native_expr.to_string(),
             RustType::F64 => format!("Value::Number({})", native_expr),
-            RustType::String => format!("Value::String({}.into())", native_expr),
+            RustType::String => format!("Value::String({}.clone().into())", native_expr),
             RustType::Bool => format!("Value::Bool({})", native_expr),
             RustType::Unit => "Value::Null".to_string(),
             RustType::Vec(inner) => {
-                let inner_to_value = inner.to_value_expr("v");
+                // Use iter()/copied()/cloned() to avoid moving the vector.
+                let (iter_suffix, val_expr) = match inner.as_ref() {
+                    RustType::F64 => (".iter().copied()", "Value::Number(v)".to_string()),
+                    RustType::Bool => (".iter().copied()", "Value::Bool(v)".to_string()),
+                    _ => (".iter().cloned()", inner.to_value_expr("v")),
+                };
                 format!(
-                    "Value::Array(Rc::new(RefCell::new({}.into_iter().map(|v| {}).collect())))",
-                    native_expr, inner_to_value
+                    "Value::Array(Rc::new(RefCell::new({}{}.map(|v| {}).collect())))",
+                    native_expr, iter_suffix, val_expr
                 )
             }
             RustType::Option(inner) => {

package/crates/tish_core/src/value.rs

@@ -25,6 +25,9 @@ pub trait TishOpaque: Send + Sync {
 
     /// Get a method by name. Returns a native function if the method exists.
     fn get_method(&self, name: &str) -> Option<NativeFn>;
+
+    /// For downcasting `Arc<dyn TishOpaque>` in native crates (e.g. Polars → `DataFrame`).
+    fn as_any(&self) -> &dyn std::any::Any;
 }
 
 /// Trait for Promise-like values that can be awaited (block until settled).

package/crates/tish_cranelift/src/lib.rs

@@ -1,6 +1,8 @@
-//! Bytecode to native via Cranelift.
+//! Standalone native binary: embedded bytecode + VM (Cranelift used as object builder).
 //!
-//! Compiles Tish bytecode to native object files and links with a minimal runtime.
+//! Produces an executable that runs **`tishlang_vm`** on serialized bytecode embedded in
+//! the binary — not lowering of Tish opcodes to CLIF/machine code (see module docs in
+//! `lower.rs`). For Rust transpile + `tishlang_runtime`, use `--native-backend rust`.
 
 mod link;
 mod lower;
@@ -25,8 +27,8 @@ impl std::fmt::Display for CraneliftError {
 
 impl std::error::Error for CraneliftError {}
 
-/// Compile a bytecode chunk to a native binary.
-/// `features` are passed to tishlang_cranelift_runtime (e.g. fs, process, http for built-in modules).
+/// Build a native binary that embeds `chunk` and runs it with the bytecode VM.
+/// `features` are passed to `tishlang_cranelift_runtime` (e.g. fs, process, http).
 pub fn compile_chunk_to_native(
     chunk: &Chunk,
     output_path: &Path,

package/crates/tish_cranelift/src/lower.rs

@@ -1,7 +1,9 @@
-//! Bytecode to Cranelift IR lowering.
+//! Embed serialized bytecode in an object file for the standalone native binary.
 //!
-//! Emits object file with tish_chunk_data and tish_chunk_len symbols.
-//! The link step builds a Rust binary that reads these and runs via tishlang_vm.
+//! **This is not AOT compilation of Tish into Cranelift IR.** The chunk is stored as
+//! read-only data (`tish_chunk_data`, `tish_chunk_len`). The link step produces an
+//! executable that **deserializes the chunk and runs `tishlang_vm`** — same VM as
+//! `tish run --backend vm`. Cranelift is only the object-file emitter for that blob.
 
 use std::path::Path;
 

package/crates/tish_cranelift_runtime/src/lib.rs

@@ -1,6 +1,8 @@
-//! Runtime for Cranelift-compiled Tish programs.
+//! Runtime linked into the `tish compile --native-backend cranelift` executable.
 //!
-//! Provides tish_run_chunk(ptr, len) which deserializes and runs bytecode.
+//! **`tish_run_chunk`** deserializes embedded bytecode and runs **`tishlang_vm`** — the same
+//! execution engine as `tish run --backend vm`. The crate name is historical; this is not
+//! running CLIF-emitted machine code for each Tish opcode.
 
 use tishlang_bytecode::deserialize;
 use tishlang_vm::Vm;

package/crates/tish_eval/src/eval.rs

@@ -75,6 +75,8 @@ pub struct Evaluator {
     module_cache: Rc<RefCell<HashMap<PathBuf, Value>>>,
     /// Directory of the file currently being evaluated (for resolving relative imports)
     current_dir: RefCell<Option<PathBuf>>,
+    /// Extra `tish:*` builtins from `TishNativeModule::virtual_builtin_modules` (shared across nested evaluators).
+    virtual_builtins: Rc<RefCell<HashMap<Arc<str>, Value>>>,
 }
 
 impl Evaluator {
@@ -173,6 +175,7 @@ impl Evaluator {
             scope,
             module_cache: Rc::new(RefCell::new(HashMap::new())),
             current_dir: RefCell::new(None),
+            virtual_builtins: Rc::new(RefCell::new(HashMap::new())),
         }
     }
 
@@ -187,6 +190,14 @@ impl Evaluator {
                 }
             }
         }
+        {
+            let mut vb = eval.virtual_builtins.borrow_mut();
+            for module in modules {
+                for (spec, value) in module.virtual_builtin_modules() {
+                    vb.insert(Arc::from(spec), value);
+                }
+            }
+        }
         eval
     }
 
@@ -502,7 +513,7 @@ impl Evaluator {
     /// Load and evaluate a module, returning its exports object. Uses cache.
     fn load_module(&mut self, from: &str) -> Result<Value, EvalError> {
         if from.starts_with("tish:") {
-            return Self::load_builtin_module(from);
+            return self.load_builtin_module(from);
         }
         let dir = self.current_dir.borrow().clone().ok_or_else(|| {
             EvalError::Error("Cannot resolve imports: no current file directory (use run_file)".to_string())
@@ -582,8 +593,11 @@ impl Evaluator {
         Ok(path)
     }
 
-    /// Load built-in module (tish:fs, tish:http, tish:process). Features auto-enabled when imported.
-    fn load_builtin_module(spec: &str) -> Result<Value, EvalError> {
+    /// Load built-in module (tish:fs, tish:http, tish:process, …) or a virtual module from native crates.
+    fn load_builtin_module(&self, spec: &str) -> Result<Value, EvalError> {
+        if let Some(v) = self.virtual_builtins.borrow().get(spec) {
+            return Ok(v.clone());
+        }
         match spec {
             "tish:fs" => {
                 #[cfg(feature = "fs")]
@@ -675,15 +689,15 @@ impl Evaluator {
             }
             _ => {
                 return Err(EvalError::Error(format!(
-                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:process, tish:ws",
+                    "Unknown built-in module: {}. Supported: tish:fs, tish:http, tish:process, tish:ws (plus any registered by native modules)",
                     spec
                 )));
             }
         }
     }
 
-    fn load_builtin_export(spec: &str, export_name: &str) -> Result<Value, EvalError> {
-        let module = Self::load_builtin_module(spec)?;
+    fn load_builtin_export(&self, spec: &str, export_name: &str) -> Result<Value, EvalError> {
+        let module = self.load_builtin_module(spec)?;
         let exports = match &module {
             Value::Object(m) => m.borrow().clone(),
             _ => return Err(EvalError::Error("Built-in module must be object".into())),
@@ -1582,7 +1596,7 @@ impl Evaluator {
                 "JSX is not supported in the interpreter. Use 'tish compile --target js' to compile to JavaScript.".to_string(),
             )),
             Expr::NativeModuleLoad { spec, export_name, .. } => {
-                Self::load_builtin_export(spec.as_ref(), export_name.as_ref())
+                self.load_builtin_export(spec.as_ref(), export_name.as_ref())
             }
             Expr::TypeOf { operand, .. } => {
                 let v = self.eval_expr(operand)?;
@@ -2015,6 +2029,7 @@ impl Evaluator {
             scope: Rc::clone(scope),
             module_cache: Rc::clone(&self.module_cache),
             current_dir: RefCell::new(self.current_dir.borrow().clone()),
+            virtual_builtins: Rc::clone(&self.virtual_builtins),
         };
         match eval.eval_statement(body) {
             Ok(v) => Ok(v),
@@ -2259,6 +2274,7 @@ impl Evaluator {
                     scope,
                     module_cache: Rc::clone(&self.module_cache),
                     current_dir: RefCell::new(self.current_dir.borrow().clone()),
+                    virtual_builtins: Rc::clone(&self.virtual_builtins),
                 };
                 match eval.eval_statement(body) {
                     Ok(v) => Ok(v),

package/crates/tish_eval/src/lib.rs

@@ -14,6 +14,7 @@ pub mod regex;
 mod value;
 
 pub use eval::Evaluator;
+pub use value::PropMap;
 pub use value::Value;
 
 /// Trait for pluggable native modules (e.g. Polars). Implement to register
@@ -21,6 +22,12 @@ pub use value::Value;
 pub trait TishNativeModule: Send + Sync {
     fn name(&self) -> &'static str;
     fn register(&self) -> std::collections::HashMap<std::sync::Arc<str>, Value>;
+
+    /// Virtual `tish:*` modules for `import { x } from 'tish:…'` (e.g. `tish:polars`).
+    /// Return `(specifier, exports_object)` pairs. Default: none.
+    fn virtual_builtin_modules(&self) -> Vec<(&'static str, Value)> {
+        vec![]
+    }
 }
 #[cfg(feature = "regex")]
 pub use regex::TishRegExp;

package/crates/tish_llvm/src/lib.rs

@@ -1,8 +1,8 @@
-//! LLVM backend for Tish.
+//! LLVM/clang link path for the **embedded-bytecode + VM** native binary.
 //!
-//! Compiles Tish bytecode to native binary using clang (LLVM toolchain).
-//! Emits a C file with embedded bytecode, compiles with clang to object code,
-//! then links with tishlang_cranelift_runtime.
+//! Emits a C file that only holds the serialized chunk as bytes; clang produces `chunk.o`,
+//! then links with **`tishlang_cranelift_runtime`** (same `tish_run_chunk` + `tishlang_vm`
+//! entry as `--native-backend cranelift`). This is **not** LLVM IR lowering of Tish opcodes.
 
 use std::fs;
 use std::path::Path;

package/crates/tish_native/src/lib.rs

@@ -1,14 +1,13 @@
 //! Native code generation backend for Tish.
 //!
-//! Target architecture (per plan):
-//! - Phase 2: Bytecode -> Cranelift IR -> .o -> link with minimal runtime
-//! - Current: Delegates to tishlang_compile (Rust codegen) + cargo build as interim path
+//! - **`rust`:** `tishlang_compile` emits Rust calling **`tishlang_runtime`** (`Value`, etc.),
+//!   then `cargo build --release` links the user binary.
+//! - **`cranelift`:** Embeds serialized bytecode in an object file and links **`tishlang_cranelift_runtime`**
+//!   — the executable runs **`tishlang_vm`** on that chunk (same as `tish run --backend vm`), not CLIF lowering.
+//! - **`llvm`:** Same embedded-bytecode + VM link path via `tishlang_llvm` / shared linker.
 //!
-//! Once Cranelift backend is implemented, this crate will:
-//! 1. Take Chunk (bytecode) as input
-//! 2. Lower to Cranelift IR
-//! 3. Emit .o via cranelift-object
-//! 4. Link against prebuilt tishlang_runtime staticlib
+//! **Future:** Lower bytecode (or typed IR) through Cranelift/LLVM to real machine code where semantics allow;
+//! emit Rust using `Vec<f64>` / fixed primitives instead of `Value` on hot paths.
 
 mod build;
 
@@ -31,9 +30,9 @@ impl std::error::Error for NativeError {}
 
 /// Compile a Tish project to a native binary.
 ///
-/// - `native_backend == "rust"`: Full Rust codegen + cargo build (supports native imports).
-/// - `native_backend == "cranelift"`: Bytecode -> Cranelift -> native (pure Tish only).
-/// - `native_backend == "llvm"`: Experimental LLVM backend (not implemented yet).
+/// - `native_backend == "rust"`: Rust source + `tishlang_runtime` + cargo (native imports).
+/// - `native_backend == "cranelift"`: Embedded bytecode + VM binary (pure Tish only); not opcode AOT yet.
+/// - `native_backend == "llvm"`: Embedded bytecode + VM via LLVM/clang link path.
 pub fn compile_to_native(
     entry_path: &Path,
     project_root: Option<&Path>,

package/crates/tish_parser/src/parser.rs

@@ -627,6 +627,12 @@ impl<'a> Parser<'a> {
                     span: self.span_end(span_start),
                 });
             }
+            let type_ann = if matches!(self.peek_kind(), Some(TokenKind::Colon)) {
+                self.advance();
+                Some(self.parse_type_annotation()?)
+            } else {
+                None
+            };
             let init_expr = if matches!(self.peek_kind(), Some(TokenKind::Assign)) {
                 self.advance();
                 Some(self.parse_expr()?)
@@ -639,7 +645,7 @@ impl<'a> Parser<'a> {
             Some(Box::new(Statement::VarDecl {
                 name,
                 mutable,
-                type_ann: None, // For-loop variables don't have type annotations (yet)
+                type_ann,
                 init: init_expr,
                 span: self.span_end(var_span_start),
             }))

package/crates/tish_runtime/src/http_fetch.rs

@@ -211,6 +211,10 @@ impl TishOpaque for HttpReadableStream {
         "ReadableStream"
     }
 
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
     fn get_method(&self, name: &str) -> Option<NativeFn> {
         if name != "getReader" {
             return None;
@@ -247,6 +251,10 @@ impl TishOpaque for HttpStreamReader {
         "ReadableStreamDefaultReader"
     }
 
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
     fn get_method(&self, name: &str) -> Option<NativeFn> {
         if name != "read" {
             return None;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, compile to native.",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {