@tishlang/tish-lsp 2.16.13 → 2.35.0

package/crates/tish_compile/src/codegen.rs

@@ -79,7 +79,12 @@ impl UsageAnalyzer {
                 }
                 self.analyze_statement(body);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 self.analyze_expr(iterable);
                 self.analyze_statement(body);
             }
@@ -330,6 +335,7 @@ fn program_uses_async(program: &Program) -> bool {
             Statement::While { body, .. }
             | Statement::For { body, .. }
             | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. }
             | Statement::DoWhile { body, .. } => stmt_has_async(body),
             Statement::Switch {
                 cases,
@@ -464,7 +470,12 @@ fn program_uses_async(program: &Program) -> bool {
                     || update.as_ref().is_some_and(expr_has_await)
                     || stmt_has_await(body)
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 expr_has_await(iterable) || stmt_has_await(body)
             }
             Statement::Return { value, .. } => value.as_ref().is_some_and(expr_has_await),
@@ -917,6 +928,13 @@ pub(crate) struct Codegen {
     module_const_f64_aliases: std::collections::HashMap<String, String>,
     /// #181: locals initialized with `new Map()` — direct `map_has`/`get`/`set`/`values` dispatch.
     map_instance_locals: std::collections::HashSet<String>,
+    /// #456 regression guard: locals initialized with `new Map()` OR `new Set()`. Arrays have no
+    /// runtime method table (`get_prop` returns Null for a method name), so `keys`/`values`/`entries`
+    /// MUST use the array fast-path — but that same fast-path would hijack a Map/Set's own
+    /// `keys`/`values`/`entries` (which DO resolve as bound methods via `get_prop`). So the array
+    /// fast-path fires by default and is suppressed only for a known collection local, which then
+    /// falls through to the generic bound-method call.
+    collection_instance_locals: std::collections::HashSet<String>,
     /// String-scan hoist: inside a `for (i; i < s.length; …)` loop over an invariant native `String`
     /// `s`, the loop body's `s.charCodeAt/charAt/at(i)` route to O(1) `Vec<char>` slice ops instead
     /// of `str_char_code_at`'s `chars().nth(i)` = O(i). Maps the source ident → the hoisted `_scN`
@@ -1143,6 +1161,7 @@ impl Codegen {
             module_const_f64_cum: std::collections::HashMap::new(),
             module_const_f64_aliases: std::collections::HashMap::new(),
             map_instance_locals: std::collections::HashSet::new(),
+            collection_instance_locals: std::collections::HashSet::new(),
             hoisted_string_chars: std::collections::HashMap::new(),
             native_fns: std::collections::HashSet::new(),
             native_fn_body_emit: false,
@@ -1308,6 +1327,7 @@ impl Codegen {
                 }
                 Statement::For { body, .. }
                 | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. }
                 | Statement::While { body, .. }
                 | Statement::DoWhile { body, .. } => {
                     Self::walk_type_aliases(std::slice::from_ref(body.as_ref()), out);
@@ -1590,13 +1610,59 @@ 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::native(|args: &[Value]| tish_read_file(args))"),
-                    "writeFile" => Some("Value::native(|args: &[Value]| tish_write_file(args))"),
+                    // tish names → the dual fs_ext functions (sync, or Node callback if a fn is passed)
+                    "readFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file(args))"),
+                    "writeFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::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))"),
-                    "readFileBytes" => Some("Value::native(|args: &[Value]| tish_read_file_bytes(args))"),
-                    "mkdir" => Some("Value::native(|args: &[Value]| tish_mkdir(args))"),
+                    "readDir" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::readdir(args))"),
+                    "readFileBytes" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file_bytes(args))"),
+                    // Node-compatible names + new methods (sync) — issue #122
+                    "readFileSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file(args))"),
+                    "readFileBytesSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file_bytes(args))"),
+                    "writeFileSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::write_file(args))"),
+                    "appendFile" | "appendFileSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::append_file(args))"),
+                    "existsSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::exists(args))"),
+                    "mkdir" | "mkdirSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::mkdir(args))"),
+                    "readdir" | "readdirSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::readdir(args))"),
+                    "stat" | "statSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::stat(args))"),
+                    "lstat" | "lstatSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::lstat(args))"),
+                    "rm" | "rmSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rm(args))"),
+                    "rmdir" | "rmdirSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rmdir(args))"),
+                    "unlink" | "unlinkSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::unlink(args))"),
+                    "rename" | "renameSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rename(args))"),
+                    "copyFile" | "copyFileSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::copy_file(args))"),
+                    "realpath" | "realpathSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::realpath(args))"),
+                    "readlink" | "readlinkSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::readlink(args))"),
+                    "truncate" | "truncateSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::truncate(args))"),
+                    "mkdtemp" | "mkdtempSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::mkdtemp(args))"),
+                    "cp" | "cpSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::cp(args))"),
+                    "access" | "accessSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::access(args))"),
+                    "constants" => Some("tishlang_runtime::fs_ext::constants()"),
+                    _ => None,
+                },
+            "tish:fs/promises" if self.has_feature("fs") => match export_name {
+                    "readFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file_promise(args))"),
+                    "readFileBytes" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::read_file_bytes_promise(args))"),
+                    "writeFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::write_file_promise(args))"),
+                    "appendFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::append_file_promise(args))"),
+                    "mkdir" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::mkdir_promise(args))"),
+                    "readdir" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::readdir_promise(args))"),
+                    "stat" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::stat_promise(args))"),
+                    "lstat" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::lstat_promise(args))"),
+                    "rm" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rm_promise(args))"),
+                    "rmdir" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rmdir_promise(args))"),
+                    "unlink" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::unlink_promise(args))"),
+                    "rename" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::rename_promise(args))"),
+                    "copyFile" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::copy_file_promise(args))"),
+                    "realpath" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::realpath_promise(args))"),
+                    "readlink" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::readlink_promise(args))"),
+                    "truncate" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::truncate_promise(args))"),
+                    "mkdtemp" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::mkdtemp_promise(args))"),
+                    "cp" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::cp_promise(args))"),
+                    "access" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::access_promise(args))"),
+                    "exists" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::exists_promise(args))"),
+                    "constants" => Some("tishlang_runtime::fs_ext::constants()"),
                     _ => None,
                 },
             "tish:http" if self.has_feature("http") => match export_name {
@@ -2175,7 +2241,7 @@ impl Codegen {
         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, 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, math_imul as tish_math_imul, math_sinh as tish_math_sinh, math_cosh as tish_math_cosh, math_tanh as tish_math_tanh, math_asinh as tish_math_asinh, math_acosh as tish_math_acosh, math_atanh as tish_math_atanh, math_cbrt as tish_math_cbrt, math_log2 as tish_math_log2, math_log10 as tish_math_log10, math_hypot as tish_math_hypot, math_atan2 as tish_math_atan2, math_asin as tish_math_asin, math_acos as tish_math_acos, math_atan as tish_math_atan, array_is_array as tish_array_is_array, array_construct as tish_array_construct, string_from_char_code as tish_string_from_char_code, string_convert as tish_string_convert, number_convert as tish_number_convert, 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, symbol_object as tish_symbol_object, tish_construct, tish_error_constructor, tish_date_constructor, tish_set_constructor, tish_map_constructor, map_get as tish_map_get, map_has as tish_map_has, map_set as tish_map_set, map_values as tish_map_values, tish_float64_array_constructor, tish_float32_array_constructor, tish_int8_array_constructor, tish_uint8_array_constructor, tish_uint8_clamped_array_constructor, tish_int16_array_constructor, tish_uint16_array_constructor, tish_int32_array_constructor, tish_uint32_array_constructor, tish_audio_context_constructor, ObjectMap, ObjectData, PropMap, TishError, Value, VmRef};\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, encode_uri_component as tish_encode_uri_component, decode_uri_component as tish_decode_uri_component, 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, math_imul as tish_math_imul, math_sinh as tish_math_sinh, math_cosh as tish_math_cosh, math_tanh as tish_math_tanh, math_asinh as tish_math_asinh, math_acosh as tish_math_acosh, math_atanh as tish_math_atanh, math_cbrt as tish_math_cbrt, math_log2 as tish_math_log2, math_log10 as tish_math_log10, math_expm1 as tish_math_expm1, math_log1p as tish_math_log1p, math_clz32 as tish_math_clz32, math_fround as tish_math_fround, math_hypot as tish_math_hypot, math_atan2 as tish_math_atan2, math_asin as tish_math_asin, math_acos as tish_math_acos, math_atan as tish_math_atan, array_is_array as tish_array_is_array, array_of as tish_array_of, array_from as tish_array_from, object_is as tish_object_is, object_has_own as tish_object_has_own, structured_clone as tish_structured_clone, array_construct as tish_array_construct, string_from_char_code as tish_string_from_char_code, string_convert as tish_string_convert, number_convert as tish_number_convert, number_is_integer as tish_number_is_integer, number_is_safe_integer as tish_number_is_safe_integer, number_is_nan as tish_number_is_nan, number_is_finite as tish_number_is_finite, 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, symbol_object as tish_symbol_object, tish_construct, tish_error_constructor, tish_date_constructor, tish_set_constructor, tish_map_constructor, map_get as tish_map_get, map_has as tish_map_has, map_set as tish_map_set, map_values as tish_map_values, tish_float64_array_constructor, tish_float32_array_constructor, tish_int8_array_constructor, tish_uint8_array_constructor, tish_uint8_clamped_array_constructor, tish_int16_array_constructor, tish_uint16_array_constructor, tish_int32_array_constructor, tish_uint32_array_constructor, tish_audio_context_constructor, ObjectMap, ObjectData, PropMap, 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");
         }
@@ -2195,6 +2261,11 @@ impl Codegen {
                 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");
             }
         }
+        // `fs/promises` (and any promise-using async program) needs the await machinery even
+        // without http. `fs` implies the runtime `promise` feature, so these resolve.
+        if self.is_async && !self.has_feature("http") && self.has_feature("fs") {
+            self.write("use tishlang_runtime::{promise_object as tish_promise_object, await_promise as tish_await_promise, await_promise_throw as tish_await_promise_throw};\n");
+        }
         if self.has_feature("fs") {
             self.write("use tishlang_runtime::{read_file as tish_read_file, read_file_bytes as tish_read_file_bytes, write_file as tish_write_file, file_exists as tish_file_exists, is_dir as tish_is_dir, read_dir as tish_read_dir, mkdir as tish_mkdir};\n");
         }
@@ -2378,6 +2449,9 @@ impl Codegen {
         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("let encodeURIComponent = Value::native(|args: &[Value]| tish_encode_uri_component(args));");
+        self.writeln("let decodeURIComponent = Value::native(|args: &[Value]| tish_decode_uri_component(args));");
+        self.writeln("let structuredClone = Value::native(|args: &[Value]| tish_structured_clone(args));");
         // `registerStaticRoute` calls the http-gated runtime fn, so only bind it when http is linked
         // (matches the conditional `use` above; otherwise non-http builds fail to resolve it).
         if self.has_feature("http") {
@@ -2439,6 +2513,10 @@ impl Codegen {
             ("cbrt", "tish_math_cbrt"),
             ("log2", "tish_math_log2"),
             ("log10", "tish_math_log10"),
+            ("expm1", "tish_math_expm1"),
+            ("log1p", "tish_math_log1p"),
+            ("clz32", "tish_math_clz32"),
+            ("fround", "tish_math_fround"),
             ("hypot", "tish_math_hypot"),
             ("atan2", "tish_math_atan2"),
             ("asin", "tish_math_asin"),
@@ -2467,6 +2545,12 @@ impl Codegen {
         self.writeln(
             "(Arc::from(\"isArray\"), Value::native(|args: &[Value]| tish_array_is_array(args))),",
         );
+        self.writeln(
+            "(Arc::from(\"of\"), Value::native(|args: &[Value]| tish_array_of(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"from\"), Value::native(|args: &[Value]| tish_array_from(args))),",
+        );
         // `Array(n)` / `new Array(n)` constructor (issue #72); `__call` covers both forms.
         self.writeln(
             "(Arc::from(\"__call\"), Value::native(|args: &[Value]| tish_array_construct(args))),",
@@ -2482,10 +2566,24 @@ impl Codegen {
         self.indent -= 1;
         self.writeln("]));");
 
-        // `Number(value)` coercion callable (issue #36).
+        // `Number(value)` coercion callable (issue #36) + the `Number.*` statics.
         self.writeln("let Number = Value::object(ObjectMap::from([");
         self.indent += 1;
         self.writeln("(Arc::from(\"__call\"), Value::native(|args: &[Value]| tish_number_convert(args))),");
+        self.writeln("(Arc::from(\"isInteger\"), Value::native(|args: &[Value]| tish_number_is_integer(args))),");
+        self.writeln("(Arc::from(\"isSafeInteger\"), Value::native(|args: &[Value]| tish_number_is_safe_integer(args))),");
+        self.writeln("(Arc::from(\"isNaN\"), Value::native(|args: &[Value]| tish_number_is_nan(args))),");
+        self.writeln("(Arc::from(\"isFinite\"), Value::native(|args: &[Value]| tish_number_is_finite(args))),");
+        self.writeln("(Arc::from(\"parseInt\"), Value::native(|args: &[Value]| tish_parse_int(args))),");
+        self.writeln("(Arc::from(\"parseFloat\"), Value::native(|args: &[Value]| tish_parse_float(args))),");
+        self.writeln("(Arc::from(\"MAX_SAFE_INTEGER\"), Value::Number(9007199254740991.0)),");
+        self.writeln("(Arc::from(\"MIN_SAFE_INTEGER\"), Value::Number(-9007199254740991.0)),");
+        self.writeln("(Arc::from(\"EPSILON\"), Value::Number(f64::EPSILON)),");
+        self.writeln("(Arc::from(\"MAX_VALUE\"), Value::Number(f64::MAX)),");
+        self.writeln("(Arc::from(\"MIN_VALUE\"), Value::Number(5e-324)),");
+        self.writeln("(Arc::from(\"POSITIVE_INFINITY\"), Value::Number(f64::INFINITY)),");
+        self.writeln("(Arc::from(\"NEGATIVE_INFINITY\"), Value::Number(f64::NEG_INFINITY)),");
+        self.writeln("(Arc::from(\"NaN\"), Value::Number(f64::NAN)),");
         self.indent -= 1;
         self.writeln("]));");
 
@@ -2500,6 +2598,15 @@ impl Codegen {
         self.writeln(
             "(Arc::from(\"assign\"), Value::native(|args: &[Value]| tish_object_assign(args))),",
         );
+        self.writeln(
+            "(Arc::from(\"is\"), Value::native(|args: &[Value]| tish_object_is(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"hasOwn\"), Value::native(|args: &[Value]| tish_object_has_own(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"getOwnPropertyNames\"), Value::native(|args: &[Value]| tish_object_keys(args))),",
+        );
         self.writeln(
             "(Arc::from(\"keys\"), Value::native(|args: &[Value]| tish_object_keys(args))),",
         );
@@ -4590,6 +4697,11 @@ impl Codegen {
                     if Self::expr_is_map_construct(init_e) {
                         self.map_instance_locals.insert(name.to_string());
                     }
+                    // #456 regression: a `new Map()`/`new Set()` local must not have its
+                    // keys/values/entries hijacked by the array fast-path.
+                    if Self::expr_is_map_construct(init_e) || Self::expr_is_set_construct(init_e) {
+                        self.collection_instance_locals.insert(name.to_string());
+                    }
                 }
 
                 // `let cum = cumulative_nv(&probs)` inherits `probs`' fixed length for in-bounds reads.
@@ -4805,6 +4917,46 @@ impl Codegen {
                 self.indent -= 1;
                 self.writeln("}");
             }
+            Statement::ForIn {
+                name,
+                name_span,
+                object,
+                body,
+                span,
+            } => {
+                // Lower `for (let k in obj)` to `for (let k of Object.keys(obj))` (#413) and reuse the
+                // native for-of emission. Object.keys yields the own enumerable keys the interpreter
+                // enumerates (insertion order for objects, index strings for arrays, `[]` for a
+                // non-object → `for (k in null)` no-ops).
+                let dummy = Span {
+                    start: (0, 0),
+                    end: (0, 0),
+                };
+                let keys_call = Expr::Call {
+                    callee: Box::new(Expr::Member {
+                        object: Box::new(Expr::Ident {
+                            name: Arc::from("Object"),
+                            span: dummy,
+                        }),
+                        prop: MemberProp::Name {
+                            name: Arc::from("keys"),
+                            span: dummy,
+                        },
+                        optional: false,
+                        span: dummy,
+                    }),
+                    args: vec![CallArg::Expr(object.clone())],
+                    span: dummy,
+                };
+                let lowered = Statement::ForOf {
+                    name: Arc::clone(name),
+                    name_span: *name_span,
+                    iterable: keys_call,
+                    body: body.clone(),
+                    span: *span,
+                };
+                self.emit_statement(&lowered)?;
+            }
             Statement::ForOf {
                 name,
                 iterable,
@@ -5591,6 +5743,9 @@ impl Codegen {
                     "isFinite",
                     "encodeURI",
                     "decodeURI",
+                    "encodeURIComponent",
+                    "decodeURIComponent",
+                    "structuredClone",
                     "htmlEscape",
                     "registerStaticRoute",
                     "String",
@@ -6728,9 +6883,15 @@ impl Codegen {
                                     return Ok(format!("tish_map_get({}, {})", map_ref, key_ref));
                                 }
                                 "set" if args.len() == 2 => {
+                                    // Borrow the key/val places (like `get`/`has`) so a keyed local
+                                    // isn't MOVED into the call and can still be used afterward — the
+                                    // runtime `map_set` clones on insert (#442). `&Value` args also
+                                    // route native-typed operands through the boxed path correctly.
+                                    let key_ref = self.emit_borrowed_arg(&args[0])?;
+                                    let val_ref = self.emit_borrowed_arg(&args[1])?;
                                     return Ok(format!(
                                         "tish_map_set({}, {}, {})",
-                                        map_ref, arg_exprs[0], arg_exprs[1]
+                                        map_ref, key_ref, val_ref
                                     ));
                                 }
                                 "values" if args.is_empty() => {
@@ -6786,9 +6947,14 @@ impl Codegen {
                         "indexOf" => {
                             let search = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
                             let from = arg_exprs.get(1).cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            // Array `indexOf` takes `Option<&Value>` fromIndex; string keeps the &Value/Null form.
+                            let from_opt = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
                             return Ok(format!(
-                                "{{ let _obj = ({}).clone(); match &_obj {{ Value::Array(_) => tishlang_runtime::array_index_of(&_obj, &{}), Value::String(_) => tishlang_runtime::string_index_of(&_obj, &{}, &{}), _ => Value::Number(-1.0) }} }}",
-                                obj_expr, search, search, from
+                                "{{ let _obj = ({}).clone(); match &_obj {{ Value::Array(_) => tishlang_runtime::array_index_of(&_obj, &{}, {}), Value::String(_) => tishlang_runtime::string_index_of(&_obj, &{}, &{}), _ => Value::Number(-1.0) }} }}",
+                                obj_expr, search, from_opt, search, from
                             ));
                         }
                         "lastIndexOf" => {
@@ -6798,9 +6964,23 @@ impl Codegen {
                             } else {
                                 "Value::Number(f64::INFINITY)".to_string()
                             };
+                            // Array lastIndexOf takes Option<&Value> fromIndex; string keeps &Value.
+                            let from_opt = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
+                            return Ok(format!(
+                                "{{ let _obj = ({}).clone(); match &_obj {{ Value::Array(_) => tishlang_runtime::array_last_index_of(&_obj, &{}, {}), Value::String(_) => tishlang_runtime::string_last_index_of(&_obj, &{}, &{}), _ => Value::Number(-1.0) }} }}",
+                                obj_expr, search, from_opt, search, position
+                            ));
+                        }
+                        "copyWithin" => {
+                            let t = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            let s = arg_exprs.get(1).cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            let e = arg_exprs.get(2).cloned().unwrap_or_else(|| "Value::Null".to_string());
                             return Ok(format!(
-                                "{{ let _obj = ({}).clone(); match &_obj {{ Value::String(_) => tishlang_runtime::string_last_index_of(&_obj, &{}, &{}), _ => Value::Number(-1.0) }} }}",
-                                obj_expr, search, position
+                                "tishlang_runtime::array_copy_within(&{}, &{}, &{}, &{})",
+                                obj_expr, t, s, e
                             ));
                         }
                         "includes" => {
@@ -6821,6 +7001,9 @@ impl Codegen {
                         "reverse" => {
                             return Ok(format!("tishlang_runtime::array_reverse(&{})", obj_expr));
                         }
+                        "toReversed" => {
+                            return Ok(format!("tishlang_runtime::array_to_reversed(&{})", obj_expr));
+                        }
                         "fill" => {
                             let value = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
                             let start = arg_exprs.get(1).cloned().unwrap_or_else(|| "Value::Null".to_string());
@@ -6879,6 +7062,26 @@ impl Codegen {
                         "trim" => {
                             return Ok(format!("tishlang_runtime::string_trim(&{})", obj_expr));
                         }
+                        "trimStart" => {
+                            return Ok(format!("tishlang_runtime::string_trim_start(&{})", obj_expr));
+                        }
+                        "trimEnd" => {
+                            return Ok(format!("tishlang_runtime::string_trim_end(&{})", obj_expr));
+                        }
+                        "normalize" => {
+                            let form = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::string_normalize(&{}, &{})",
+                                obj_expr, form
+                            ));
+                        }
+                        "codePointAt" => {
+                            let idx = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::string_code_point_at(&{}, &{})",
+                                obj_expr, idx
+                            ));
+                        }
                         "toUpperCase" => {
                             return Ok(format!("tishlang_runtime::string_to_upper_case(&{})", obj_expr));
                         }
@@ -6887,16 +7090,24 @@ impl Codegen {
                         }
                         "startsWith" => {
                             let search = arg_exprs.first().cloned().unwrap_or_else(|| "Value::String(\"\".into())".to_string());
+                            let pos = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
                             return Ok(format!(
-                                "tishlang_runtime::string_starts_with(&{}, &{})",
-                                obj_expr, search
+                                "tishlang_runtime::string_starts_with(&{}, &{}, {})",
+                                obj_expr, search, pos
                             ));
                         }
                         "endsWith" => {
                             let search = arg_exprs.first().cloned().unwrap_or_else(|| "Value::String(\"\".into())".to_string());
+                            let pos = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
                             return Ok(format!(
-                                "tishlang_runtime::string_ends_with(&{}, &{})",
-                                obj_expr, search
+                                "tishlang_runtime::string_ends_with(&{}, &{}, {})",
+                                obj_expr, search, pos
                             ));
                         }
                         "replace" => {
@@ -6926,6 +7137,13 @@ impl Codegen {
                                 obj_expr, regexp
                             ));
                         }
+                        "matchAll" if self.has_feature("regex") => {
+                            let regexp = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::string_match_all_regex(&{}, &{})",
+                                obj_expr, regexp
+                            ));
+                        }
                         "search" if self.has_feature("regex") => {
                             let regexp = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
                             return Ok(format!(
@@ -6987,6 +7205,20 @@ impl Codegen {
                                 obj_expr, digits
                             ));
                         }
+                        "toExponential" => {
+                            let digits = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::number_to_exponential(&{}, &{})",
+                                obj_expr, digits
+                            ));
+                        }
+                        "toPrecision" => {
+                            let precision = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::number_to_precision(&{}, &{})",
+                                obj_expr, precision
+                            ));
+                        }
                         "toString" => {
                             let radix = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
                             return Ok(format!(
@@ -7024,11 +7256,41 @@ impl Codegen {
                                 }
                             }
                             let callback = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            // `array_reduce` takes `Option<&Value>` init: `None` = no initial value, so an
+                            // empty array with no init throws (per JS) instead of returning `null`.
+                            let init_arg = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
+                            return Ok(format!(
+                                "tishlang_runtime::array_reduce(&{}, &{}, {})",
+                                obj_expr, callback, init_arg
+                            ));
+                        }
+                        "reduceRight" => {
+                            let callback = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            let init_arg = match arg_exprs.get(1) {
+                                Some(e) => format!("Some(&{})", e),
+                                None => "None".to_string(),
+                            };
                             return Ok(format!(
-                                "tishlang_runtime::array_reduce(&{}, &{}, &{})",
-                                obj_expr, callback, initial
+                                "tishlang_runtime::array_reduce_right(&{}, &{}, {})",
+                                obj_expr, callback, init_arg
                             ));
                         }
+                        // keys/values/entries exist on BOTH arrays and Map/Set. Arrays have no runtime
+                        // method table, so they need this fast-path; a known Map/Set local instead
+                        // falls through to the generic bound-method call (its get_prop resolves them).
+                        // (#456 regression — the unguarded arms hijacked `m.keys()`/`s.values()`.)
+                        "keys" if !self.kve_defers_to_generic(object.as_ref()) => {
+                            return Ok(format!("tishlang_runtime::array_keys(&{})", obj_expr));
+                        }
+                        "values" if !self.kve_defers_to_generic(object.as_ref()) => {
+                            return Ok(format!("tishlang_runtime::array_values(&{})", obj_expr));
+                        }
+                        "entries" if !self.kve_defers_to_generic(object.as_ref()) => {
+                            return Ok(format!("tishlang_runtime::array_entries(&{})", obj_expr));
+                        }
                         "forEach" => {
                             let callback = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
                             return Ok(format!(
@@ -7133,6 +7395,38 @@ impl Codegen {
                                 obj_expr, start, delete_count, items
                             ));
                         }
+                        "toSpliced" => {
+                            let start = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Number(0.0)".to_string());
+                            let delete_count = arg_exprs.get(1).map(|d| format!("Some(&{})", d)).unwrap_or_else(|| "None".to_string());
+                            let items = if arg_exprs.len() > 2 {
+                                let items_vec = arg_exprs[2..].iter()
+                                    .map(|a| format!("{}.clone()", a))
+                                    .collect::<Vec<_>>()
+                                    .join(", ");
+                                format!("&[{}]", items_vec)
+                            } else {
+                                "&[]".to_string()
+                            };
+                            return Ok(format!(
+                                "tishlang_runtime::array_to_spliced(&{}, &{}, {}, {})",
+                                obj_expr, start, delete_count, items
+                            ));
+                        }
+                        "toSorted" => {
+                            let comparator = arg_exprs.first().map(|c| format!("Some(&{})", c)).unwrap_or_else(|| "None".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::array_to_sorted(&{}, {})",
+                                obj_expr, comparator
+                            ));
+                        }
+                        "with" => {
+                            let index = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            let value = arg_exprs.get(1).cloned().unwrap_or_else(|| "Value::Null".to_string());
+                            return Ok(format!(
+                                "tishlang_runtime::array_with(&{}, &{}, &{})",
+                                obj_expr, index, value
+                            ));
+                        }
                         "flat" => {
                             let depth = arg_exprs.first().cloned().unwrap_or_else(|| "Value::Number(1.0)".to_string());
                             return Ok(format!(
@@ -8175,7 +8469,12 @@ impl Codegen {
                 }
                 Self::collect_assigned_idents_in_stmt(body, names);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::collect_assigned_idents_in_expr(iterable, names);
                 Self::collect_assigned_idents_in_stmt(body, names);
             }
@@ -8311,7 +8610,12 @@ impl Codegen {
                     || update.as_ref().is_some_and(|u| Self::expr_has_length_changer(u))
                     || Self::stmt_has_length_changer(body)
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::expr_has_length_changer(iterable) || Self::stmt_has_length_changer(body)
             }
             Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
@@ -8338,6 +8642,7 @@ impl Codegen {
                 | "normalize" | "localeCompare" | "map" | "filter" | "reduce" | "reduceRight"
                 | "forEach" | "find" | "findIndex" | "findLast" | "findLastIndex" | "some" | "every"
                 | "join" | "flat" | "flatMap" | "keys" | "values" | "entries"
+                | "toReversed" | "toSorted" | "with" | "toSpliced"
         )
     }
 
@@ -8448,7 +8753,12 @@ impl Codegen {
                     || update.as_ref().is_some_and(|u| Self::expr_changes_base_len(u, base))
                     || Self::stmt_changes_base_len(body, base)
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::expr_changes_base_len(iterable, base) || Self::stmt_changes_base_len(body, base)
             }
             Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
@@ -8857,7 +9167,12 @@ impl Codegen {
                 }
                 Self::collect_captured_block_vars_from_statements(body, block_vars, result);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::collect_captured_block_vars_from_expr(iterable, block_vars, result);
                 Self::collect_captured_block_vars_from_statements(body, block_vars, result);
             }
@@ -8995,7 +9310,8 @@ impl Codegen {
                 }
                 Self::collect_local_var_names(body, names);
             }
-            Statement::ForOf { body, .. } => Self::collect_local_var_names(body, names),
+            Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::collect_local_var_names(body, names),
             Statement::While { body, .. } | Statement::DoWhile { body, .. } => {
                 Self::collect_local_var_names(body, names);
             }
@@ -9261,7 +9577,12 @@ impl Codegen {
                 }
                 Self::collect_stmt_idents(body, idents);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::collect_expr_idents(iterable, idents);
                 Self::collect_stmt_idents(body, idents);
             }
@@ -12150,6 +12471,18 @@ impl Codegen {
                 }
                 _ => false,
             },
+            // `Math.imul(a, b)` — an exact int32-domain node (emits an i32 `wrapping_mul`, see
+            // `emit_int32_operand`), so it participates in an int32 chain when both operands are
+            // themselves int32-lowerable. Lets `h = Math.imul(h, K) >>> 0` keep `h` in a register
+            // across the loop instead of narrowing/widening `h` on every op.
+            Expr::Call { callee, args, .. } => {
+                matches!(callee.as_ref(),
+                    Expr::Member { object, prop: MemberProp::Name { name: m, .. }, .. }
+                        if m.as_ref() == "imul"
+                            && matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Math"))
+                    && matches!(args.as_slice(), [CallArg::Expr(a0), CallArg::Expr(a1)]
+                        if self.i32_chain_lowerable(a0, var) && self.i32_chain_lowerable(a1, var))
+            }
             _ => false,
         }
     }
@@ -12391,6 +12724,7 @@ impl Codegen {
             }
             Statement::For { body, .. }
             | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. }
             | Statement::While { body, .. }
             | Statement::DoWhile { body, .. } => {
                 Self::collect_ordered_assigns_to(body, var, out)
@@ -12415,6 +12749,7 @@ impl Codegen {
             }
             Statement::For { body, .. }
             | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. }
             | Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
             | Statement::FunDecl { body, .. } => f(std::slice::from_ref(body)),
@@ -12480,7 +12815,12 @@ impl Codegen {
                 }
                 Self::for_each_stmt_expr(body, f);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 f(iterable);
                 Self::for_each_stmt_expr(body, f);
             }
@@ -12893,7 +13233,11 @@ impl Codegen {
                         Self::collect_annotated_types(std::slice::from_ref(e), aliases, env);
                     }
                 }
-                Statement::While { body, .. } | Statement::DoWhile { body, .. } => {
+                // for-in's loop var is always a string key, so it gets no Vec-element type binding —
+                // it behaves like while/do-while here (recurse the body only).
+                Statement::While { body, .. }
+                | Statement::DoWhile { body, .. }
+                | Statement::ForIn { body, .. } => {
                     Self::collect_annotated_types(std::slice::from_ref(body), aliases, env)
                 }
                 Statement::ForOf {
@@ -13037,7 +13381,12 @@ impl Codegen {
                 }
                 Self::collect_reassignments_stmt(body, out);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 Self::collect_reassignments_expr(iterable, out);
                 Self::collect_reassignments_stmt(body, out);
             }
@@ -13299,6 +13648,22 @@ impl Codegen {
                         }
                     }
                 }
+                // Two-arg `Math.imul(a, b)` → an exact 32-bit product (a number). Modelled so a value
+                // fed by it (`h = Math.imul(h, K) >>> 0`) is not demoted to a boxed `Value`.
+                if let [CallArg::Expr(_), CallArg::Expr(_)] = args.as_slice() {
+                    if let Expr::Member {
+                        object,
+                        prop: MemberProp::Name { name: method, .. },
+                        ..
+                    } = callee.as_ref()
+                    {
+                        if method.as_ref() == "imul"
+                            && matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Math")
+                        {
+                            return RustType::F64;
+                        }
+                    }
+                }
                 // #169: a fused native `Vec<f64>` reduce produces an `f64` (the emitter lowers it via
                 // `native_vec_hof_for_call`). Model it here so an accumulator fed by `xs.reduce(...)`
                 // is not wrongly demoted to a boxed `Value`. Conservative: any miss → `Value`.
@@ -13984,7 +14349,16 @@ impl Codegen {
                         self.emit_native_fn_body(&statements[i])?;
                     } else {
                         self.emit_statement(&statements[i])?;
-                        if Self::stmt_may_throw(&statements[i]) && !Self::is_terminator_stmt(&statements[i]) {
+                        // Same guard as the primary emit site above: a native-typed frame
+                        // (`-> f64`/`-> Vec<..>`/`-> ()`) can't type the `Err`/`Value::Null` check, so
+                        // suppress it there — the parked throw still surfaces at the first Value/Result
+                        // frame up the chain. Without this guard the strict-`<` fast-path emitted an
+                        // untypeable checkpoint after any may-throw stmt (e.g. an index read post-#425),
+                        // breaking pure-numeric fixtures like fannkuch.
+                        if Self::stmt_may_throw(&statements[i])
+                            && !Self::is_terminator_stmt(&statements[i])
+                            && (self.try_closure_depth > 0 || !self.in_native_typed_frame())
+                        {
                             self.emit_pending_throw_check();
                         }
                     }
@@ -14115,7 +14489,8 @@ impl Codegen {
                 }
                 Self::walk_stmt_for_module_const_disqualifiers(body, g, bad);
             }
-            Statement::ForOf { body, .. } => {
+            Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => {
                 Self::walk_stmt_for_module_const_disqualifiers(body, g, bad);
             }
             Statement::Switch {
@@ -14536,6 +14911,32 @@ impl Codegen {
         )
     }
 
+    fn expr_is_set_construct(expr: &Expr) -> bool {
+        matches!(
+            expr,
+            Expr::New {
+                callee,
+                ..
+            } if matches!(callee.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Set")
+        )
+    }
+
+    /// #456 regression guard: should `<object>.keys()/.values()/.entries()` DEFER to the generic
+    /// bound-method call instead of the array fast-path? True when `object` is not an array:
+    /// - the `Object` global (`Object.keys/values/entries` are STATICS → `tish_object_*`),
+    /// - a known `new Map()`/`new Set()` local, or a direct `new Map(…)`/`new Set(…)` receiver
+    ///   (their keys/values/entries resolve as bound methods via `get_prop`).
+    /// Arrays (everything else) keep the fast-path — they have no runtime method table.
+    fn kve_defers_to_generic(&self, object: &Expr) -> bool {
+        match object {
+            Expr::Ident { name, .. } => {
+                let n = name.as_ref();
+                n == "Object" || self.collection_instance_locals.contains(n)
+            }
+            _ => Self::expr_is_map_construct(object) || Self::expr_is_set_construct(object),
+        }
+    }
+
     /// #176 — classify top-level `let x = <number-literal>` bindings whose every use is a numeric
     /// read or a whole-binding assign with a numeric-shaped RHS (fasta `seed`).
     fn collect_native_numeric_globals(stmts: &[Statement]) -> HashMap<String, f64> {
@@ -14865,7 +15266,8 @@ impl Codegen {
             Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
             | Statement::For { body, .. }
-            | Statement::ForOf { body, .. } => {
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => {
                 Self::walk_stmt_for_global_disqualifiers(body, g, bad);
             }
             Statement::Switch {
@@ -15105,7 +15507,12 @@ impl Codegen {
                 f(cond);
                 Self::for_each_expr_root_stmt(body, f);
             }
-            Statement::ForOf { iterable, body, .. } => {
+            Statement::ForOf { iterable, body, .. }
+            | Statement::ForIn {
+                object: iterable,
+                body,
+                ..
+            } => {
                 f(iterable);
                 Self::for_each_expr_root_stmt(body, f);
             }
@@ -15717,12 +16124,16 @@ impl Codegen {
                     }
                     Expr::Member { object, prop: MemberProp::Name { name: m, .. }, .. } => {
                         matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Math")
-                            && args.len() == 1
-                            && matches!(
-                                m.as_ref(),
-                                "sqrt" | "sin" | "cos" | "tan" | "abs" | "floor" | "ceil" | "exp"
-                                    | "trunc" | "log"
-                            )
+                            && ((args.len() == 1
+                                && matches!(
+                                    m.as_ref(),
+                                    "sqrt" | "sin" | "cos" | "tan" | "abs" | "floor" | "ceil"
+                                        | "exp" | "trunc" | "log"
+                                ))
+                                // 2-arg `Math.imul` inlines to an exact i32 wrapping multiply — a
+                                // native-safe numeric primitive (no dispatch), so a fn using it (FNV
+                                // with imul, xmur3/mulberry32 PRNGs) stays eligible for native typing.
+                                || (args.len() == 2 && m.as_ref() == "imul"))
                     }
                     _ => false,
                 }
@@ -18325,7 +18736,8 @@ impl Codegen {
             Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
             | Statement::For { body, .. }
-            | Statement::ForOf { body, .. } => Self::rec_collect_returns(body, out),
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::rec_collect_returns(body, out),
             _ => {}
         }
     }
@@ -18469,7 +18881,8 @@ impl Codegen {
             }
             Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
-            | Statement::ForOf { body, .. } => Self::rec_orch_binds_node(body, builders),
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::rec_orch_binds_node(body, builders),
             Statement::For { init, body, .. } => {
                 init.as_ref()
                     .is_some_and(|i| Self::rec_orch_binds_node(i, builders))
@@ -20553,7 +20966,8 @@ impl Codegen {
             }
             Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
-            | Statement::ForOf { body, .. } => Self::agg_collect_aliases(body, p, out),
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::agg_collect_aliases(body, p, out),
             _ => {}
         }
     }
@@ -20581,7 +20995,8 @@ impl Codegen {
             Statement::For { body, .. }
             | Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
-            | Statement::ForOf { body, .. } => Self::agg_stmt_writes(body, p, aliases),
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::agg_stmt_writes(body, p, aliases),
             _ => false,
         }
     }
@@ -20705,7 +21120,8 @@ impl Codegen {
             Statement::For { body, .. }
             | Statement::While { body, .. }
             | Statement::DoWhile { body, .. }
-            | Statement::ForOf { body, .. } => Self::stmt_returns_value(body),
+            | Statement::ForOf { body, .. }
+            | Statement::ForIn { body, .. } => Self::stmt_returns_value(body),
             _ => false,
         }
     }
@@ -20764,6 +21180,30 @@ impl Codegen {
                 return Ok(Some(code));
             }
         }
+        // `Math.imul(a, b)` in an int32 context → the raw i32 `wrapping_mul` (no f64 excursion, no
+        // `to_int32` round-trip on the product), when both operands are themselves int32-lowerable.
+        // JS ES6 semantics (ToInt32 both operands, wrapping 32-bit multiply, signed result) are carried
+        // by the operands' own int32 lowering. Keeps `h = Math.imul(h, K) >>> 0` fully register-domain.
+        if let Expr::Call { callee, args, .. } = e {
+            if let [CallArg::Expr(a0), CallArg::Expr(a1)] = args.as_slice() {
+                if let Expr::Member {
+                    object,
+                    prop: MemberProp::Name { name: m, .. },
+                    ..
+                } = callee.as_ref()
+                {
+                    if m.as_ref() == "imul"
+                        && matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Math")
+                    {
+                        let ai = self.emit_int32_operand(a0)?;
+                        let bi = self.emit_int32_operand(a1)?;
+                        if let (Some(ai), Some(bi)) = (ai, bi) {
+                            return Ok(Some(format!("(({}).wrapping_mul({}))", ai, bi)));
+                        }
+                    }
+                }
+            }
+        }
         // Integer-literal leaf: `ToInt32(<int literal>)` is a compile-time constant — emit it
         // directly (`v as i32` = modulo 2^32 = JS ToInt32 of the integer) instead of a runtime
         // `to_int32(1_f64)` call. Removes the constant round-trip in masks/shift-counts
@@ -21334,6 +21774,35 @@ impl Codegen {
                         }
                     }
                 }
+                // `Math.imul(a, b)` → an inline exact 32-bit wrapping multiply (ES6: ToInt32 both
+                // operands, wrapping i32 multiply, signed int32 result). Both args go through
+                // `emit_int32_operand` — the SAME ToInt32 lowering the bitwise path uses — so this is
+                // bit-for-bit identical to the boxed `tish_math_imul` and to V8: typed==boxed==node
+                // holds. It eliminates the per-call arg boxing + `value_call` a hot hashing/PRNG loop
+                // (xmur3, mulberry32, FNV-with-imul) would otherwise pay. A general primitive (fires
+                // for any `Math.imul`), not a fixture-specific kernel emission (cf. #317). Falls
+                // through to the boxed call when an operand isn't int32-lowerable.
+                if let [CallArg::Expr(a0), CallArg::Expr(a1)] = args.as_slice() {
+                    if let Expr::Member {
+                        object,
+                        prop: MemberProp::Name { name: method, .. },
+                        ..
+                    } = callee.as_ref()
+                    {
+                        if method.as_ref() == "imul"
+                            && matches!(object.as_ref(), Expr::Ident { name, .. } if name.as_ref() == "Math")
+                        {
+                            let ai = self.emit_int32_operand(a0)?;
+                            let bi = self.emit_int32_operand(a1)?;
+                            if let (Some(ai), Some(bi)) = (ai, bi) {
+                                return Ok((
+                                    format!("(({}).wrapping_mul({}) as f64)", ai, bi),
+                                    RustType::F64,
+                                ));
+                            }
+                        }
+                    }
+                }
                 if let [CallArg::Expr(arg_expr)] = args.as_slice() {
                     if let Expr::Member {
                         object,