@tishlang/tish-lsp 2.39.0 → 2.43.8

package/crates/tish_compile/src/codegen.rs

@@ -589,6 +589,12 @@ pub fn compile_project_full_emit(
 > {
     use crate::resolve;
     let root = project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
+    // Install the import-scheme registry (built-ins + any `tish.schemes` from package.json) for
+    // this build, so resolution and codegen recognize `asset:` and any project-declared scheme.
+    crate::schemes::set_active(crate::schemes::SchemeRegistry::from_project(root));
+    // (The narrow-int/`fixed`/`i32` numeric profile is set from `emit_mode` in
+    // `compile_with_native_modules_emit`, the funnel every entry point reaches — not here — so it
+    // can't leak across compiles on a shared thread. Resolution/inference don't lower annotations.)
     let modules = resolve::resolve_project(entry_path, project_root).map_err(|e| CompileError {
         message: e,
         span: None,
@@ -660,6 +666,11 @@ pub fn compile_with_native_modules(
     native_init: &std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     optimize: bool,
 ) -> Result<String, CompileError> {
+    // This non-project entry (reached by `compile`/`compile_with_features`, never the GBA project
+    // path) compiles an already-resolved program, so no scheme registry was installed for it. Reset
+    // to the empty built-in set, in case a prior GBA compile on this thread left one active — a
+    // normal program has no scheme imports, but this keeps per-compile thread-local state hermetic.
+    crate::schemes::set_active(crate::schemes::SchemeRegistry::builtin());
     compile_with_native_modules_emit(
         program,
         project_root,
@@ -708,6 +719,24 @@ pub fn compile_with_native_modules_emit(
     optimize: bool,
     emit_mode: crate::NativeEmitMode,
 ) -> Result<String, CompileError> {
+    // Per-compile thread-local state — the narrow-int/`fixed`/`i32` numeric profile and the import-
+    // scheme registry — must not outlive THIS compile. Both persist on the thread, so a later compile
+    // on the same thread (LSP, `cargo test` workers share threads) could inherit a prior GBA compile's
+    // state and lower those annotations natively off-GBA / see stale schemes — diverging from the
+    // interpreter. This funnel is the one point every entry reaches, so reset both to their defaults
+    // on the way OUT, even on panic (mirrors tish_resolve's guard). Then set the numeric profile for
+    // THIS compile from the always-correct `emit_mode`. The scheme registry is installed before
+    // resolution by `compile_project_full_emit` (it must exist during resolve); the guard only clears
+    // it afterward so it can't leak forward.
+    struct StateGuard;
+    impl Drop for StateGuard {
+        fn drop(&mut self) {
+            crate::types::set_gba_numerics(false);
+            crate::schemes::set_active(crate::schemes::SchemeRegistry::builtin());
+        }
+    }
+    let _state_guard = StateGuard;
+    crate::types::set_gba_numerics(emit_mode == crate::NativeEmitMode::Gba);
     let program = if optimize {
         tishlang_opt::optimize(program)
     } else {
@@ -742,13 +771,77 @@ pub fn compile_with_native_modules_emit(
     g.has_native_ui_host = native_modules.iter().any(|m| {
         m.package_name == "tish-macos"
             || m.package_name == "tish-ios"
+            || m.crate_name == "tish_macos"
             || m.crate_name == "tishlang_macos"
+            || m.crate_name == "tish_ios"
             || m.crate_name == "tishlang_ios"
     });
     g.emit_program(&program)?;
     Ok(g.output)
 }
 
+/// Rewrite the `std::` paths that survive in `Gba`-mode generated code into their
+/// `core::` equivalents (the emitted crate is `#![no_std]`). Applied once to the
+/// whole output. Each pattern is a specific fully-qualified Rust path — none occur
+/// inside escaped user string literals — so the textual pass is safe. Callers add
+/// to this table as the thumbv4t corpus build surfaces new sites.
+fn gba_no_std_rewrite(src: String) -> String {
+    // Apply the fixups only to CODE, never to the contents of string literals: a user
+    // string that happens to contain one of these patterns (e.g. `let s = "std::mem::x"`)
+    // must be left byte-for-byte intact. We scan the generated source, copy each `"…"`
+    // literal through verbatim (respecting `\` escapes), and rewrite only the code between
+    // them. (`"` and `\` are ASCII, so a byte scan is UTF-8 safe; char literals can't hold
+    // these multi-char patterns, and any stray `'"'` at worst *misses* a fixup — a loud
+    // no_std compile error — never a silent string corruption.)
+    let bytes = src.as_bytes();
+    let mut out = String::with_capacity(src.len());
+    let mut seg_start = 0;
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'"' {
+            out.push_str(&gba_rewrite_code(&src[seg_start..i]));
+            let str_start = i;
+            i += 1;
+            while i < bytes.len() {
+                match bytes[i] {
+                    b'\\' => i += 2, // skip the escape and the (ASCII) escaped byte
+                    b'"' => {
+                        i += 1;
+                        break;
+                    }
+                    _ => i += 1,
+                }
+            }
+            out.push_str(&src[str_start..i.min(bytes.len())]);
+            seg_start = i;
+        } else {
+            i += 1;
+        }
+    }
+    out.push_str(&gba_rewrite_code(&src[seg_start..]));
+    out
+}
+
+/// The std::→core::/facade path fixups, applied only to non-string-literal code by
+/// [`gba_no_std_rewrite`]. Callers extend this table as the thumbv4t corpus build surfaces
+/// new sites (a surviving `std::` path is a loud `#![no_std]` compile error, not silent).
+fn gba_rewrite_code(src: &str) -> String {
+    src.replace("std::error::Error", "core::error::Error")
+        .replace("std::f64::consts", "core::f64::consts")
+        .replace("std::cmp::Ordering", "core::cmp::Ordering")
+        .replace("std::mem::", "core::mem::")
+        .replace("std::slice::", "core::slice::")
+        // Struct→Value boundary conversions (`object_from_pairs`) and a few other
+        // sites emit fully-qualified `::std::sync::Arc` / `std::sync::Arc`. The Gba
+        // prelude imports `Arc` (= facade Rc alias), so map both to it. The `::`
+        // form must be replaced first (it contains the non-`::` form).
+        .replace("::std::sync::Arc", "Arc")
+        .replace("std::sync::Arc", "Arc")
+        // hashbrown lacks `From<[_; N]>` with a custom hasher; route object-literal
+        // construction through the facade helper.
+        .replace("ObjectMap::from(", "tishlang_runtime::object_map_from(")
+}
+
 /// #177 (S-E/S-F): the return shape of a de-virtualized aggregate (struct/array) free fn.
 #[derive(Debug, Clone, PartialEq)]
 enum AggRet {
@@ -784,7 +877,7 @@ struct AggFnSig {
     ret: AggRet,
 }
 
-/// #178 (behind `TISH_REC_STRUCT`): a recursive struct shape inferred *structurally* (no name
+/// #178 (default-on via `native_opts_enabled`): a recursive struct shape inferred *structurally* (no name
 /// matching) from object literals whose fields are either scalars or recursive self-references.
 /// Drives native lowering of tree/list builders and consumers to `Option<Box<T>>` + native fns —
 /// the real, name-independent binary_trees lowering. See docs/recursive-struct-native.md.
@@ -915,7 +1008,7 @@ pub(crate) struct Codegen {
     /// Variables currently wrapped in Rc<RefCell<Value>> for mutable capture in closures
     /// These need special handling: reads via .borrow().clone(), writes via *var.borrow_mut()
     refcell_wrapped_vars: std::collections::HashSet<String>,
-    /// #176 (behind `TISH_NATIVE_FN`): top-level `let` bindings lowered to `thread_local Cell<f64>`
+    /// #176 (default-on via `native_opts_enabled`): top-level `let` bindings lowered to `thread_local Cell<f64>`
     /// (`G_NAME`) when every use is a numeric read or a whole-binding numeric assign (fasta `seed`).
     native_numeric_globals: std::collections::HashMap<String, f64>,
     /// Top-level `let name = [f64 literals…]` never reassigned — emitted as `const G_name: [f64; N]`
@@ -940,7 +1033,7 @@ pub(crate) struct Codegen {
     /// of `str_char_code_at`'s `chars().nth(i)` = O(i). Maps the source ident → the hoisted `_scN`
     /// `Vec<char>` binding; populated for the loop body's extent only.
     hoisted_string_chars: std::collections::HashMap<String, String>,
-    /// M5 (dark-shipped behind `TISH_NATIVE_FN`): top-level functions eligible for a parallel
+    /// M5 (default-on via `native_opts_enabled`): top-level functions eligible for a parallel
     /// free `fn f_native(f64,..)->f64` (all params `: number`, returns `number`, native-safe
     /// body). Direct calls to these route to the native fn, bypassing the boxed `value_call`.
     native_fns: std::collections::HashSet<String>,
@@ -1001,7 +1094,7 @@ pub(crate) struct Codegen {
     /// nested call site these are already `&/&mut Vec<T>` references, so they pass through by reborrow
     /// (`&mut *p`) rather than being address-of'd like a local `Vec` (`&mut local`).
     vec_ref_params: std::collections::HashMap<String, bool>,
-    /// #320 (behind TISH_NATIVE_ARR_PARAM): normal boxed-closure fns that take one or more READ-ONLY
+    /// #320 (default-on via `native_opts_enabled`): normal boxed-closure fns that take one or more READ-ONLY
     /// `number[]` params (e.g. k_nucleotide's `kNucleotide(seq, k)` — indexes `seq` but returns a
     /// boxed Map). Per param: `true` = unbox the boxed arg into an owned native `Vec<f64>` so the
     /// body indexes it natively (`seq[i+j]` → f64), `false` = leave it on its normal path. The fn
@@ -1009,10 +1102,10 @@ pub(crate) struct Codegen {
     /// native. Computed by `Self::native_arr_param_fns`, the SAME pure fn infer reads (agreement
     /// contract — see `infer::native_vec_array_params`), disjoint from `native_vec_fns`.
     native_arr_param_fns: std::collections::HashMap<String, Vec<bool>>,
-    /// #177 S-E/S-F (dark-shipped behind `TISH_AGGREGATE_INFER`): the unboxed struct alias name
+    /// #177 S-E/S-F (default-on via `native_opts_enabled`): the unboxed struct alias name
     /// (e.g. `TishAnon_0`) when the interprocedural aggregate path is active for this program,
     /// else `None`. Set in `emit_program` only after the de-virtualized fns emit successfully.
-    /// #178: inferred recursive-struct lowering plan (behind `TISH_REC_STRUCT`).
+    /// #178: inferred recursive-struct lowering plan (default-on via `native_opts_enabled`).
     rec_struct_plan: Option<RecStructPlan>,
     aggregate_alias: Option<String>,
     /// #177: fn name → its de-virtualized native signature. Calls to these route directly to the
@@ -1108,6 +1201,11 @@ pub(crate) struct Codegen {
     /// closures it must not return a `Result` from a `Value`-returning closure.
     value_fn_depth: u32,
     emit_mode: crate::NativeEmitMode,
+    /// Scheme imports as `(scheme_name, absolute_path)`, in first-seen order. Populated (Gba mode)
+    /// before the entry is emitted from the active [`crate::schemes`] registry; drives the
+    /// `mod __scheme_<name>_<j> { … }` blocks and their per-scheme registration. The handle a tish
+    /// name binds to is its index AMONG same-scheme entries (= its slot in that scheme's arena).
+    scheme_files: Vec<(String, String)>,
     /// Program links `tish:macos` / `tish:ios` — skip HeadlessHost install.
     has_native_ui_host: bool,
     /// Program references browser global `document` — inject tish-canvas.
@@ -1120,6 +1218,10 @@ pub(crate) struct Codegen {
     cse_subst: Vec<(Expr, String)>,
     /// Monotonic counter for unique CSE temp names (`_cse0`, `_cse1`, …).
     cse_temp_counter: usize,
+    /// The program's used NON-ASCII characters (collected from every string literal), as a sorted
+    /// string. Fed to import schemes via `{charset}` so a scheme can bake only the glyphs a program
+    /// actually uses — e.g. `font<N>:` bakes ASCII + these, not all ~24k glyphs of a CJK font.
+    string_charset: String,
 }
 
 /// One `map`/`filter` stage of a fused HOF chain (#317): the single-element-param closure's
@@ -1146,6 +1248,7 @@ impl Codegen {
             indent: 0,
             loop_label_index: 0,
             is_async: false,
+            string_charset: String::new(),
             features,
             native_module_init,
             async_context_stack: Vec::new(),
@@ -1213,6 +1316,7 @@ impl Codegen {
             program_fun_decl_names: std::collections::HashSet::new(),
             value_fn_depth: 0,
             emit_mode: crate::NativeEmitMode::DesktopBin,
+            scheme_files: Vec::new(),
             has_native_ui_host: false,
             program_uses_document: false,
             cse_subst: Vec::new(),
@@ -1346,6 +1450,160 @@ impl Codegen {
     /// an object shape. Each generated struct derives `Clone` + `Debug`
     /// (cheap; field types are all `Copy`-or-cheap-clone in practice) and
     /// is named `TishStruct_<TishAlias>`.
+    /// Split a lowered scheme spec (`<prefix><abspath>`) into `(scheme_name, abspath)` using the
+    /// active registry. `None` if the spec isn't a registered scheme.
+    fn split_scheme_spec(spec: &str) -> Option<(String, String)> {
+        crate::schemes::with_active(|reg| {
+            reg.matches(spec).map(|s| {
+                let prefix = s.prefix();
+                let rest = spec.strip_prefix(&prefix).unwrap_or(spec).to_string();
+                (s.name.clone(), rest)
+            })
+        })
+    }
+
+    /// Populate [`Self::scheme_files`] from the program's scheme imports. Each was lowered (resolve
+    /// phase) to a top-level `let name = NativeModuleLoad { spec: "<prefix><abspath>" }`, so a flat
+    /// scan of the top-level statements finds them all. De-duplicated on `(scheme, path)`.
+    fn collect_scheme_files(&mut self, stmts: &[Statement]) {
+        for s in stmts {
+            if let Statement::VarDecl {
+                init: Some(Expr::NativeModuleLoad { spec, .. }),
+                ..
+            } = s
+            {
+                if let Some(entry) = Self::split_scheme_spec(spec.as_ref()) {
+                    if !self.scheme_files.contains(&entry) {
+                        self.scheme_files.push(entry);
+                    }
+                }
+            }
+        }
+    }
+
+    /// The runtime arena a scheme registers into, keyed by its (pre-render) `register` template.
+    /// Schemes that share a template share an arena: `asset:` and `sheet:` both call
+    /// `__asset_register_sheet`, so both index into the same runtime `Vec`. `None` for a scheme with
+    /// no registration call (nothing to index into).
+    fn scheme_arena_key(&self, scheme: &str) -> Option<String> {
+        let emit = self.scheme_target_emit(scheme).ok()?;
+        (!emit.register.is_empty()).then_some(emit.register)
+    }
+
+    /// The handle a scheme spec binds to — its slot in the runtime ARENA it registers into. The
+    /// arena is keyed by the scheme's `register` target, NOT its name: `asset:` and `sheet:` both
+    /// push to `__asset_register_sheet`, so a program mixing them must number handles across BOTH
+    /// (the entry registers every scheme file in one first-seen pass, so same-arena entries land in
+    /// exactly this order). Numbering per-scheme-name collided their handles — an `asset:` and a
+    /// `sheet:` import each got handle 0 while the runtime gave them slots 0 and 1 (#552).
+    fn scheme_handle_of(&self, spec: &str) -> Option<usize> {
+        let (scheme, path) = Self::split_scheme_spec(spec)?;
+        let arena = self.scheme_arena_key(&scheme)?;
+        let mut k = 0usize;
+        for (s, p) in &self.scheme_files {
+            if self.scheme_arena_key(s).as_deref() != Some(arena.as_str()) {
+                continue;
+            }
+            if *s == scheme && *p == path {
+                return Some(k);
+            }
+            k += 1;
+        }
+        None
+    }
+
+    /// The generated `mod` identifier for the `j`-th collected scheme file.
+    fn scheme_mod_ident(scheme: &str, j: usize) -> String {
+        format!("__scheme_{}_{}", scheme, j)
+    }
+
+    /// Emit one `mod __scheme_<name>_<j> { … }` per collected scheme file (Gba only), from the
+    /// scheme's `gba` emit template: its `use`s, module body (the include macro, `{path}` → the
+    /// absolute file), and a same-module accessor (which can see the macro's private statics — the
+    /// only way a tagless image's sprites escape). Registration into the runtime arena happens in
+    /// the entry below.
+    /// Collect every NON-ASCII character appearing in the program's string literals, sorted+unique.
+    /// Fed to schemes via `{charset}` (see `render_template`) so a `font<N>:` import can bake only the
+    /// glyphs actually used. ASCII is always baked by the scheme, so it's excluded here. Runtime-built
+    /// strings (concatenation, numbers) resolve to ASCII, which is covered; a non-ASCII char reachable
+    /// only through a computed string is the rare gap (documented — add it to a literal if needed).
+    fn collect_string_charset(stmts: &[Statement]) -> String {
+        let mut set = std::collections::BTreeSet::new();
+        fn add(s: &str, set: &mut std::collections::BTreeSet<char>) {
+            for c in s.chars() {
+                if (c as u32) >= 0x7F {
+                    set.insert(c);
+                }
+            }
+        }
+        fn walk(stmts: &[Statement], set: &mut std::collections::BTreeSet<char>) {
+            for s in stmts {
+                Codegen::for_each_stmt_expr(s, &mut |e| {
+                    Codegen::nv_for_each_subexpr(e, &mut |x| {
+                        if let Expr::Literal { value: Literal::String(str), .. } = x {
+                            add(str, set);
+                        }
+                        if let Expr::TemplateLiteral { quasis, .. } = x {
+                            for q in quasis {
+                                add(q, set);
+                            }
+                        }
+                    });
+                });
+                Codegen::for_each_child_stmt_list(s, &mut |list| walk(list, set));
+            }
+        }
+        walk(stmts, &mut set);
+        set.into_iter().collect()
+    }
+
+    fn emit_scheme_modules(&mut self) -> Result<(), CompileError> {
+        let files = self.scheme_files.clone();
+        for (j, (scheme, path)) in files.iter().enumerate() {
+            let emit = self.scheme_target_emit(scheme)?;
+            let module_ident = Self::scheme_mod_ident(scheme, j);
+            self.writeln(&format!("mod {} {{", module_ident));
+            self.indent += 1;
+            for u in &emit.uses {
+                self.writeln(u);
+            }
+            self.writeln(&crate::schemes::render_template(
+                &emit.module_body,
+                path,
+                &module_ident,
+                &self.string_charset,
+            ));
+            if !emit.accessor.is_empty() {
+                self.writeln(&emit.accessor);
+            }
+            self.indent -= 1;
+            self.writeln("}");
+        }
+        if !files.is_empty() {
+            self.writeln("");
+        }
+        Ok(())
+    }
+
+    /// The `gba` [`crate::schemes::TargetEmit`] for `scheme`, or a compile error if the scheme has
+    /// no template for this target.
+    fn scheme_target_emit(
+        &self,
+        scheme: &str,
+    ) -> Result<crate::schemes::TargetEmit, CompileError> {
+        crate::schemes::with_active(|reg| {
+            reg.matches(&format!("{}:", scheme))
+                .and_then(|s| s.targets.get("gba").cloned())
+        })
+        .ok_or_else(|| CompileError {
+            message: format!(
+                "import scheme '{}:' has no emit template for target 'gba'",
+                scheme
+            ),
+            span: None,
+        })
+    }
+
     fn emit_named_struct_decls(&mut self) {
         // Snapshot keys + values so we can mutate `self` (writing the
         // emitted source) inside the loop.
@@ -2245,15 +2503,38 @@ impl Codegen {
     }
 
     fn emit_program(&mut self, program: &Program) -> Result<(), CompileError> {
+        // Only GBA `font<N>:`/`emoji:` schemes consume `{charset}` (and both `render_template`
+        // callers that read `string_charset` are Gba-gated), so skip the whole-program string walk
+        // for every other target — its result is never read off-GBA.
+        if self.emit_mode == crate::NativeEmitMode::Gba {
+            self.string_charset = Self::collect_string_charset(&program.statements);
+        }
         self.is_async = program_uses_async(program);
         self.program_has_jsx = tishlang_ui::jsx::program_contains_jsx(program);
         self.program_fun_decl_names = tishlang_ui::jsx::collect_fun_decl_names(program);
         self.program_uses_document = crate::resolve::program_uses_document(program);
-        self.write("#![allow(unused, non_snake_case)]\n\n");
-        self.write("use std::cell::RefCell;\n");
-        self.write("use std::rc::Rc;\n");
-        self.write("use std::sync::Arc;\n");
-        self.write("use tishlang_runtime::{console_debug as tish_console_debug, console_info as tish_console_info, console_log as tish_console_log, console_warn as tish_console_warn, console_error as tish_console_error, boolean as tish_boolean, decode_uri as tish_decode_uri, encode_uri as tish_encode_uri, 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.emit_mode == crate::NativeEmitMode::Gba {
+            // no_std GBA ROM: alloc-based, Arc aliases to Rc in the facade. The
+            // prelude `use tishlang_runtime::{…}` below is unchanged — those names
+            // are re-exported by the tishlang_runtime_gba facade.
+            self.write("#![no_std]\n#![no_main]\n#![allow(unused, non_snake_case)]\n\n");
+            self.write("extern crate alloc;\n");
+            self.write("use core::cell::RefCell;\n");
+            self.write("use alloc::rc::Rc;\n");
+            self.write("use alloc::boxed::Box;\n");
+            self.write("use alloc::vec::Vec;\n");
+            self.write("use alloc::string::{String, ToString};\n");
+            self.write("use alloc::{vec, format};\n");
+            self.write("use tishlang_runtime::Arc;\n");
+            // f64 transcendentals for inline math (`Math.sqrt(x)` → `x.sqrt()`).
+            self.write("use tishlang_runtime::FloatExt;\n");
+        } else {
+            self.write("#![allow(unused, non_snake_case)]\n\n");
+            self.write("use std::cell::RefCell;\n");
+            self.write("use std::rc::Rc;\n");
+            self.write("use std::sync::Arc;\n");
+        }
+        self.write("use tishlang_runtime::{console_debug as tish_console_debug, console_info as tish_console_info, console_log as tish_console_log, console_warn as tish_console_warn, console_error as tish_console_error, boolean as tish_boolean, decode_uri as tish_decode_uri, encode_uri as tish_encode_uri, 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_freeze as tish_object_freeze, object_is_frozen as tish_object_is_frozen, 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");
         }
@@ -2309,6 +2590,16 @@ impl Codegen {
         // and `x.field` becomes a direct field access.
         self.emit_named_struct_decls();
 
+        // `asset:` imports (Gba only): collect the distinct files (each an i32 sheet handle) and
+        // emit one `mod __asset_F { include_aseprite_inner!("<abspath>"); pub fn sheet() }` block.
+        // The inner macro's `SPRITES` static is private, so the same-module `sheet()` accessor is
+        // how the frames escape the module (a tagless image exposes no public tag). Registration
+        // into the facade arena happens in the entry below, before `run()`.
+        if self.emit_mode == crate::NativeEmitMode::Gba {
+            self.collect_scheme_files(&program.statements);
+            self.emit_scheme_modules()?;
+        }
+
         if self.is_async && self.emit_mode == crate::NativeEmitMode::DesktopBin {
             self.writeln("#[tokio::main]");
             self.writeln("async fn main() {");
@@ -2331,9 +2622,36 @@ impl Codegen {
             self.writeln("}");
             self.writeln("");
         }
-        // M5 (dark-shipped behind TISH_NATIVE_FN): emit a parallel native `fn f_native` for each
-        // eligible top-level numeric fn at top level; direct calls route to it in emit_typed_expr.
-        if crate::native_opts_enabled() {
+        if self.emit_mode == crate::NativeEmitMode::Gba {
+            // agb runtime entry: hand the peripherals to the facade, run the
+            // program body, then halt. (Async lands in P5 — `run()` is sync here.)
+            self.writeln("#[agb::entry]");
+            self.writeln("fn agb_main(gba: agb::Gba) -> ! {");
+            self.indent += 1;
+            self.writeln("tishlang_runtime::gba::init(gba);");
+            // Register each scheme file into its runtime arena, in first-seen order, so the handle a
+            // tish name binds to (its per-scheme index) matches the arena slot it gets here.
+            let scheme_files = self.scheme_files.clone();
+            for (j, (scheme, _path)) in scheme_files.iter().enumerate() {
+                let emit = self.scheme_target_emit(scheme)?;
+                if !emit.register.is_empty() {
+                    let module_ident = Self::scheme_mod_ident(scheme, j);
+                    let call = crate::schemes::render_template(&emit.register, "", &module_ident, &self.string_charset);
+                    self.writeln(&format!("{};", call));
+                }
+            }
+            self.writeln("let _ = run();");
+            self.writeln("tishlang_runtime::gba::halt()");
+            self.indent -= 1;
+            self.writeln("}");
+            self.writeln("");
+        }
+        // M5 (default-on via native_opts_enabled; TISH_NATIVE_OPT=0 opts out): emit a parallel
+        // native `fn f_native` for each eligible top-level numeric fn at top level; direct calls
+        // route to it in emit_typed_expr.
+        // Gba mode: these passes emit `thread_local!` and other std-isms; gate them off initially
+        // (they are pure perf — correctness is unaffected). Re-audit for no_std later.
+        if crate::native_opts_enabled() && self.emit_mode != crate::NativeEmitMode::Gba {
             self.native_numeric_globals =
                 Self::collect_native_numeric_globals(&program.statements);
             if !self.native_numeric_globals.is_empty() {
@@ -2378,21 +2696,21 @@ impl Codegen {
                 self.writeln("");
             }
         }
-        // #177 (S-E/S-F, dark-shipped behind TISH_AGGREGATE_INFER): de-virtualize the nbody-shape
+        // #177 (S-E/S-F, default-on via native_opts_enabled): de-virtualize the nbody-shape
         // aggregate fns into native Rust free fns operating on an unboxed `Vec<TishStruct_alias>`
         // threaded by reference. Computed + emitted here (before `run()`); if any fn can't be
         // lowered the whole path is disabled and we fall back to the boxed closures unchanged.
         if crate::native_opts_enabled() {
             self.setup_aggregate_fns(program);
         }
-        // #178 (behind TISH_REC_STRUCT): de-virtualize recursive-struct builders/consumers into
+        // #178 (default-on via native_opts_enabled): de-virtualize recursive-struct builders/consumers into
         // native free fns over `Option<Box<T>>` structs (the real binary_trees fix). Structural,
         // name-independent; emits before `run()` with scratch-buffer rollback so any unsupported
         // construct cleanly disables the path and falls back to the boxed closures unchanged.
         if crate::native_opts_enabled() {
             self.setup_rec_struct_plan(program);
         }
-        // #175 (behind TISH_NATIVE_FN): de-virtualize fns over plain `number[]`/`boolean[]` params
+        // #175 (default-on via native_opts_enabled): de-virtualize fns over plain `number[]`/`boolean[]` params
         // into native free fns threaded by `&/&mut Vec<T>` (spectral_norm / queens). Runs after the
         // aggregate path so it can skip any fn that path already claimed; emits before `run()` with
         // its own scratch-buffer rollback so a failure leaves the boxed closures untouched.
@@ -2403,7 +2721,7 @@ impl Codegen {
             self.inline_fns = Self::collect_inline_fns(program);
             self.setup_native_vec_fns(program);
         }
-        // #320 (behind TISH_NATIVE_ARR_PARAM): normal fns taking read-only `number[]` params get
+        // #320 (default-on via native_opts_enabled): normal fns taking read-only `number[]` params get
         // those params unboxed to native owned `Vec<f64>` (boxed body + boxed return otherwise), so
         // `seq[i+j]` indexes natively. The SAME pure detection infer reads to keep the caller's array
         // `number[]`, so the two never disagree about which args pass as native arrays.
@@ -2441,7 +2759,9 @@ impl Codegen {
         }
         self.nonneg_locals = self.collect_nonneg_locals(&program.statements);
         self.shift_half_of = Self::collect_shift_half_of(&program.statements);
-        if self.is_async {
+        // Gba mode is sync in P2 (real async lowering is P5); `std::error::Error` in
+        // the signature is rewritten to `core::error::Error` by the no_std post-pass.
+        if self.is_async && self.emit_mode != crate::NativeEmitMode::Gba {
             self.writeln("async fn run() -> Result<(), Box<dyn std::error::Error>> {");
         } else if self.emit_mode == crate::NativeEmitMode::EmbeddedLib {
             self.writeln("pub fn run() -> Result<(), Box<dyn std::error::Error>> {");
@@ -2545,6 +2865,15 @@ impl Codegen {
         }
         self.writeln("(Arc::from(\"PI\"), Value::Number(std::f64::consts::PI)),");
         self.writeln("(Arc::from(\"E\"), Value::Number(std::f64::consts::E)),");
+        // #539: the remaining ECMAScript Math value constants (were missing → `null`).
+        self.writeln("(Arc::from(\"LN2\"), Value::Number(std::f64::consts::LN_2)),");
+        self.writeln("(Arc::from(\"LN10\"), Value::Number(std::f64::consts::LN_10)),");
+        self.writeln("(Arc::from(\"LOG2E\"), Value::Number(std::f64::consts::LOG2_E)),");
+        self.writeln("(Arc::from(\"LOG10E\"), Value::Number(std::f64::consts::LOG10_E)),");
+        self.writeln("(Arc::from(\"SQRT2\"), Value::Number(std::f64::consts::SQRT_2)),");
+        self.writeln(
+            "(Arc::from(\"SQRT1_2\"), Value::Number(std::f64::consts::FRAC_1_SQRT_2)),",
+        );
         self.indent -= 1;
         self.writeln("]));");
         self.writeln("let JSON = Value::object(ObjectMap::from([");
@@ -2623,6 +2952,12 @@ impl Codegen {
         self.writeln(
             "(Arc::from(\"getOwnPropertyNames\"), Value::native(|args: &[Value]| tish_object_keys(args))),",
         );
+        self.writeln(
+            "(Arc::from(\"freeze\"), Value::native(|args: &[Value]| tish_object_freeze(args))),",
+        );
+        self.writeln(
+            "(Arc::from(\"isFrozen\"), Value::native(|args: &[Value]| tish_object_is_frozen(args))),",
+        );
         self.writeln(
             "(Arc::from(\"keys\"), Value::native(|args: &[Value]| tish_object_keys(args))),",
         );
@@ -2820,6 +3155,14 @@ impl Codegen {
             self.indent -= 1;
             self.writeln("}");
         }
+        // Gba mode: rewrite the handful of `std::` paths that survive in emitted
+        // code into their `core::` equivalents (the crate is `#![no_std]`). These
+        // are specific Rust path patterns, not substrings that occur in escaped
+        // user string literals, so a targeted textual pass is safe. Any new site
+        // is caught by the thumbv4t corpus build.
+        if self.emit_mode == crate::NativeEmitMode::Gba {
+            self.output = gba_no_std_rewrite(core::mem::take(&mut self.output));
+        }
         Ok(())
     }
 
@@ -2842,7 +3185,12 @@ impl Codegen {
     /// unchanged, and `PropMap` dedup + hidden-class shapes key by text, not pointer — so shapes,
     /// insertion order, and `Object.keys` are all unaffected. Same inline-`static` idiom as the
     /// per-site `PropIC` caches.
-    fn cached_object_key(k: &str) -> String {
+    fn cached_object_key(&self, k: &str) -> String {
+        if self.emit_mode == crate::NativeEmitMode::Gba {
+            // No `OnceLock` on no_std GBA; emit a direct interned key (`Arc` = `Rc`).
+            // Object-literal keys in a hot loop are a later perf item on GBA.
+            return format!("Arc::from({:?})", k);
+        }
         format!(
             "{{ static K: ::std::sync::OnceLock<::std::sync::Arc<str>> = \
              ::std::sync::OnceLock::new(); K.get_or_init(|| ::std::sync::Arc::from({:?})).clone() }}",
@@ -2979,7 +3327,24 @@ impl Codegen {
                         }
                     }
                 }
-                if matches!(rust_type, RustType::F64 | RustType::Bool | RustType::String) {
+                // Narrow int local (`let hp: u8 = …; hp = hp - 1`): compute the RHS (promoted to
+                // `f64` by the binary emitter) and truncate-cast to the width on store. No
+                // int32-register trick — these are plain storage locals.
+                if rust_type.is_narrow_int() {
+                    let escaped = Self::escape_ident(name.as_ref());
+                    let native_val = self.emit_coerced_native(value, &rust_type)?;
+                    if self.refcell_wrapped_vars.contains(name.as_ref()) {
+                        return Ok(format!(
+                            "{{ let _t = {}; *{}.borrow_mut() = _t; }}",
+                            native_val, escaped
+                        ));
+                    }
+                    return Ok(format!("{} = {}", escaped, native_val));
+                }
+                if matches!(
+                    rust_type,
+                    RustType::F64 | RustType::Fixed | RustType::Bool | RustType::String
+                ) {
                     if let Expr::Index { object, index, .. } = value.as_ref() {
                         if let Expr::Ident { name: arr_name, .. } = object.as_ref() {
                             if self.index_in_bounds(index, arr_name.as_ref()) {
@@ -3029,6 +3394,47 @@ impl Codegen {
             }
             // `s += x` etc. in statement position: native f64 compound op, no boxed return.
             Expr::CompoundAssign { name, op, value, .. } => {
+                // Narrow int compound-assign (`hp -= 3`): compute in `f64` (JS Number semantics),
+                // truncate-cast back to the width — same model as a narrow-int plain assign, no box.
+                if self.type_context.get_type(name.as_ref()).is_narrow_int() {
+                    let width = self.type_context.get_type(name.as_ref()).to_rust_type_str();
+                    let n = Self::escape_ident(name.as_ref()).into_owned();
+                    let is_refcell = self.refcell_wrapped_vars.contains(name.as_ref());
+                    let (rhs_code, rhs_ty) = self.emit_typed_expr(value)?;
+                    let rhs_f64 = if rhs_ty == RustType::F64 {
+                        rhs_code
+                    } else if rhs_ty.is_integer_scalar() {
+                        format!("(({}) as f64)", rhs_code)
+                    } else {
+                        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 => "%",
+                    };
+                    let read = if is_refcell {
+                        format!("(*{}.borrow())", n)
+                    } else {
+                        n.clone()
+                    };
+                    let new_val =
+                        format!("((({}) as f64) {} {}) as {}", read, op_str, rhs_f64, width);
+                    if is_refcell {
+                        return Ok(format!(
+                            "{{ let _t = {}; *{}.borrow_mut() = _t; }}",
+                            new_val, n
+                        ));
+                    }
+                    return Ok(format!("{} = {}", n, new_val));
+                }
                 if self.type_context.get_type(name.as_ref()) == RustType::F64 {
                     let n = Self::escape_ident(name.as_ref());
                     let is_refcell = self.refcell_wrapped_vars.contains(name.as_ref());
@@ -5057,10 +5463,10 @@ impl Codegen {
                     // re-boxing each element to `Value::Number` for the loop body.
                     self.writeln("Value::NumberArray(ref _arr) => {");
                     self.indent += 1;
-                    self.writeln("for _v in _arr.borrow().iter() {");
+                    self.writeln("for _v in _arr.borrow().to_values() {");
                     self.indent += 1;
                     self.writeln(&format!(
-                        "let {} = Value::Number(*_v);",
+                        "let {} = _v;",
                         Self::escape_ident(name.as_ref())
                     ));
                     self.emit_statement(body)?;
@@ -5843,14 +6249,15 @@ impl Codegen {
                         sibling_escaped, sibling_escaped
                     ));
                 }
-                // Extract just the parameter names (type annotations are parsed but not used in codegen yet)
+                // Extract just the parameter names for capture bookkeeping (typed params get
+                // native shadows below — the M1 block)
                 let current_param_names: Vec<String> = params
                     .iter()
                     .flat_map(|p| p.bound_names())
                     .map(|n| n.to_string())
                     .collect();
                 let formal_span = *span;
-                // M1 (keystone, dark-shipped behind TISH_PARAM_NATIVE): a typed scalar param
+                // M1 (keystone; default-on via native_opts_enabled): a typed scalar param
                 // normally arrives boxed (`args.get(i).cloned()`), which poisons native math in
                 // the body (e.g. `i*N+k` boxes). Bind a *native shadow* — coerce once to f64/
                 // bool/String — so the body lowers it like a native local. Conservative: only
@@ -5893,7 +6300,9 @@ impl Codegen {
                                 // `arr[oob]`→NaN) is unreachable for sound inputs but never panics.
                                 self.writeln(&format!(
                                     "let mut {}: Vec<f64> = match args.get({}) {{ \
-                                       Some(Value::NumberArray(a)) => a.borrow().clone(), \
+                                       Some(Value::NumberArray(a)) => match &*a.borrow() {{ \
+                                           tishlang_runtime::NumArrayBacking::Packed(p) => p.clone(), \
+                                           tishlang_runtime::NumArrayBacking::Boxed(b) => b.iter().map(|v| match v {{ Value::Number(n) => *n, _ => f64::NAN }}).collect() }}, \
                                        Some(Value::Array(arr)) => arr.borrow().iter().map(|v| match v {{ Value::Number(n) => *n, _ => f64::NAN }}).collect(), \
                                        _ => Vec::new() }};",
                                     Self::escape_ident(tp.name.as_ref()),
@@ -7261,7 +7670,7 @@ impl Codegen {
                         }
                         "reduce" => {
                             let initial = arg_exprs.get(1).cloned().unwrap_or_else(|| "Value::Null".to_string());
-                            // Fused reduce (TISH_FUSED_HOF): `arr.reduce((acc, x) => acc OP x, init)`
+                            // Fused reduce (default-on via native_opts_enabled): `arr.reduce((acc, x) => acc OP x, init)`
                             // with a plain binop of the two params → a native fold using the SAME
                             // runtime Value op the closure body would, eliminating the per-element
                             // `value_call`. Sound (identical Value semantics, incl. string `+`).
@@ -7600,10 +8009,11 @@ impl Codegen {
                          tishlang_runtime::get_prop(&o, {}) }} }}",
                         obj, key
                     )
-                } else if ic_eligible {
+                } else if ic_eligible && self.emit_mode != crate::NativeEmitMode::Gba {
                     // Per-site inline cache: a block-scoped `static` cell unique to this member-read
                     // site (#179). Caches (shape, slot) so repeat reads skip the key scan. Behaviour is
                     // identical to `get_prop` — non-cacheable objects fall through inside `get_prop_ic`.
+                    // Gba: `PropIC` uses atomics (unavailable on thumbv4t) — use the plain path.
                     format!(
                         "{{ static IC: tishlang_runtime::PropIC = tishlang_runtime::PropIC::new(); \
                          tishlang_runtime::get_prop_ic(&{}, {}, &IC) }}",
@@ -7730,7 +8140,7 @@ impl Codegen {
                         match prop {
                             ObjectProp::KeyValue(k, v, _) => {
                                 let val = self.emit_expr(v)?;
-                                let key = Self::cached_object_key(k.as_ref());
+                                let key = self.cached_object_key(k.as_ref());
                                 if self.should_clone(v) {
                                     parts.push(format!("_obj.insert({}, ({}).clone());", key, val));
                                 } else {
@@ -7753,7 +8163,7 @@ impl Codegen {
                         init = format!("let mut _obj: PropMap = PropMap::with_capacity({});", literal_keys);
                     }
                     format!(
-                        "{{ {} {} Value::Object(VmRef::new(ObjectData {{ strings: _obj, symbols: None }})) }}",
+                        "{{ {} {} Value::Object(VmRef::new(ObjectData {{ strings: _obj, symbols: None, frozen: false }})) }}",
                         init,
                         parts.join(" ")
                     )
@@ -7762,7 +8172,7 @@ impl Codegen {
                     for prop in props {
                         if let ObjectProp::KeyValue(k, v, _) = prop {
                             let val = self.emit_expr(v)?;
-                            let key = Self::cached_object_key(k.as_ref());
+                            let key = self.cached_object_key(k.as_ref());
                             if self.should_clone(v) {
                                 parts.push(format!("({}, ({}).clone())", key, val));
                             } else {
@@ -8258,6 +8668,27 @@ impl Codegen {
                 )
             }
             Expr::NativeModuleLoad { spec, export_name, .. } => {
+                // A scheme import (`asset:`, or any project-declared scheme) binds to an i32 handle
+                // — its per-scheme index, registered into a runtime arena by the generated
+                // `agb_main`. Only valid in Gba mode; no other target bakes scheme files into a ROM.
+                if crate::schemes::is_scheme_import(spec.as_ref()) {
+                    if self.emit_mode != crate::NativeEmitMode::Gba {
+                        return Err(CompileError {
+                            message: format!(
+                                "scheme import '{}' requires --target gba",
+                                spec.as_ref()
+                            ),
+                            span: None,
+                        });
+                    }
+                    let handle = self.scheme_handle_of(spec.as_ref()).ok_or_else(|| {
+                        CompileError {
+                            message: format!("internal: scheme import '{}' not collected", spec.as_ref()),
+                            span: None,
+                        }
+                    })?;
+                    return Ok(format!("Value::Number({} as f64)", handle));
+                }
                 self.native_module_rust_init(spec.as_ref(), export_name.as_ref())
                     .ok_or_else(|| CompileError {
                         message: if crate::resolve::is_builtin_native_spec(spec.as_ref()) {
@@ -9519,6 +9950,187 @@ impl Codegen {
         }
     }
 
+    /// Every name BOUND anywhere inside `s` — `let`/`const` (incl. destructuring), fn/arrow
+    /// params, `for…of`/`for…in` loop vars, `catch` params, and nested `FunDecl` names —
+    /// descending into nested arrow and function bodies. Unlike `collect_local_var_names`
+    /// (which skips arrow bodies) or `collect_binding_names` (which skips `let`/`const`),
+    /// this is the complete binder set of the subtree. Used by the arrow emitter's implicit
+    /// env-capture fallback so a NESTED closure's own bindings are never mistaken for capture
+    /// requirements of the closure being emitted (#467: `(a)=>(b)=>(c)=> …` E0425'd because
+    /// the middle arrow tried to capture the innermost arrow's param `c`).
+    fn collect_bound_names_deep(s: &Statement, out: &mut HashSet<String>) {
+        use Statement::*;
+        let ce = Self::collect_bound_names_deep_expr;
+        match s {
+            VarDecl { name, init, .. } => {
+                out.insert(name.to_string());
+                if let Some(i) = init {
+                    ce(i, out);
+                }
+            }
+            VarDeclDestructure { pattern, init, .. } => {
+                Self::collect_destruct_names(pattern, out);
+                ce(init, out);
+            }
+            FunDecl { name, params, body, .. } => {
+                out.insert(name.to_string());
+                for p in params {
+                    for n in p.bound_names() {
+                        out.insert(n.to_string());
+                    }
+                }
+                Self::collect_bound_names_deep(body, out);
+            }
+            ForOf { name, iterable, body, .. } => {
+                out.insert(name.to_string());
+                ce(iterable, out);
+                Self::collect_bound_names_deep(body, out);
+            }
+            ForIn { name, object, body, .. } => {
+                out.insert(name.to_string());
+                ce(object, out);
+                Self::collect_bound_names_deep(body, out);
+            }
+            Try { body, catch_param, catch_body, finally_body, .. } => {
+                if let Some(cp) = catch_param {
+                    out.insert(cp.to_string());
+                }
+                Self::collect_bound_names_deep(body, out);
+                if let Some(c) = catch_body {
+                    Self::collect_bound_names_deep(c, out);
+                }
+                if let Some(f) = finally_body {
+                    Self::collect_bound_names_deep(f, out);
+                }
+            }
+            Block { statements, .. } | Multi { statements, .. } => {
+                statements.iter().for_each(|x| Self::collect_bound_names_deep(x, out))
+            }
+            If { cond, then_branch, else_branch, .. } => {
+                ce(cond, out);
+                Self::collect_bound_names_deep(then_branch, out);
+                if let Some(eb) = else_branch {
+                    Self::collect_bound_names_deep(eb, out);
+                }
+            }
+            While { cond, body, .. } | DoWhile { body, cond, .. } => {
+                ce(cond, out);
+                Self::collect_bound_names_deep(body, out);
+            }
+            For { init, cond, update, body, .. } => {
+                if let Some(i) = init {
+                    Self::collect_bound_names_deep(i, out);
+                }
+                if let Some(c) = cond {
+                    ce(c, out);
+                }
+                if let Some(u) = update {
+                    ce(u, out);
+                }
+                Self::collect_bound_names_deep(body, out);
+            }
+            ExprStmt { expr, .. } => ce(expr, out),
+            Return { value: Some(v), .. } => ce(v, out),
+            Throw { value, .. } => ce(value, out),
+            Switch { expr, cases, default_body, .. } => {
+                ce(expr, out);
+                for (g, b) in cases {
+                    if let Some(ge) = g {
+                        ce(ge, out);
+                    }
+                    b.iter().for_each(|x| Self::collect_bound_names_deep(x, out));
+                }
+                if let Some(d) = default_body {
+                    d.iter().for_each(|x| Self::collect_bound_names_deep(x, out));
+                }
+            }
+            Export { declaration, .. } => {
+                if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
+                    Self::collect_bound_names_deep(inner, out);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// Expression side of [`Self::collect_bound_names_deep`]: recurse every child; an
+    /// `ArrowFunction` contributes its params and descends into its body.
+    fn collect_bound_names_deep_expr(e: &Expr, out: &mut HashSet<String>) {
+        let ce = Self::collect_bound_names_deep_expr;
+        match e {
+            Expr::ArrowFunction { params, body, .. } => {
+                for p in params {
+                    for n in p.bound_names() {
+                        out.insert(n.to_string());
+                    }
+                }
+                match body {
+                    ArrowBody::Expr(x) => ce(x, out),
+                    ArrowBody::Block(b) => Self::collect_bound_names_deep(b, out),
+                }
+            }
+            Expr::Call { callee, args, .. } | Expr::New { callee, args, .. } => {
+                ce(callee, out);
+                for a in args {
+                    if let CallArg::Expr(x) | CallArg::Spread(x) = a {
+                        ce(x, out);
+                    }
+                }
+            }
+            Expr::Binary { left, right, .. } | Expr::NullishCoalesce { left, right, .. } => {
+                ce(left, out);
+                ce(right, out);
+            }
+            Expr::Unary { operand, .. } => ce(operand, out),
+            Expr::TypeOf { operand, .. } => ce(operand, out),
+            Expr::Delete { target, .. } => ce(target, out),
+            Expr::Await { operand, .. } => ce(operand, out),
+            Expr::Conditional { cond, then_branch, else_branch, .. } => {
+                ce(cond, out);
+                ce(then_branch, out);
+                ce(else_branch, out);
+            }
+            Expr::Index { object, index, .. } => {
+                ce(object, out);
+                ce(index, out);
+            }
+            Expr::IndexAssign { object, index, value, .. } => {
+                ce(object, out);
+                ce(index, out);
+                ce(value, out);
+            }
+            Expr::Member { object, prop, .. } => {
+                ce(object, out);
+                if let MemberProp::Expr(pe) = prop {
+                    ce(pe, out);
+                }
+            }
+            Expr::MemberAssign { object, value, .. } => {
+                ce(object, out);
+                ce(value, out);
+            }
+            Expr::Assign { value, .. }
+            | Expr::CompoundAssign { value, .. }
+            | Expr::LogicalAssign { value, .. } => ce(value, out),
+            Expr::Array { elements, .. } => {
+                for el in elements {
+                    match el {
+                        ArrayElement::Expr(x) | ArrayElement::Spread(x) => ce(x, out),
+                    }
+                }
+            }
+            Expr::Object { props, .. } => {
+                for pr in props {
+                    match pr {
+                        ObjectProp::KeyValue(_, x, _) | ObjectProp::Spread(x) => ce(x, out),
+                    }
+                }
+            }
+            Expr::TemplateLiteral { exprs, .. } => exprs.iter().for_each(|x| ce(x, out)),
+            _ => {}
+        }
+    }
+
     fn collect_destruct_names(pattern: &DestructPattern, names: &mut HashSet<String>) {
         match pattern {
             DestructPattern::Array(elements) => {
@@ -9777,7 +10389,14 @@ impl Codegen {
             }
         }
         // Only clone builtins that are actually referenced (clone so outer scope can still use, e.g. process for PORT)
+        // #513: every name on the BUILTINS skip-list below MUST also be clone-hoisted here (or
+        // lower as a constant, like Infinity/NaN). A name skipped by the implicit env-capture
+        // fallback but NOT hoisted is referenced raw inside the `move` closure — which MOVES it
+        // out of the enclosing `Fn` closure's capture (E0507: `serve`/`Boolean` in any nested
+        // value-closure that also captures a local, e.g. a `Promise.spawn(fn() { serve(port, …) })`).
         for builtin in &[
+            "Boolean",
+            "serve",
             "console",
             "Math",
             "JSON",
@@ -9844,6 +10463,20 @@ impl Codegen {
             .cloned()
             .collect();
         already_captured.extend(BUILTINS.iter().map(|s| s.to_string()));
+        // #467: names bound INSIDE this body's nested closures (their params and locals) show up
+        // in `referenced` — `collect_referenced_idents` has no binder awareness — but they are not
+        // free variables of THIS closure, and capturing them emits a clone of an ident that does
+        // not exist in the enclosing scope (E0425: `(a)=>(b)=>(c)=> …`'s middle arrow tried to
+        // capture the innermost arrow's own param `c`). Subtract the subtree's full binder set.
+        // Corner accepted: a name that is BOTH bound in a nested closure AND genuinely free at
+        // this level via the implicit fallback (an enclosing-closure local, not an outer param/
+        // var) is skipped too — that fails loudly at compile time (E0425), never silently, and
+        // the primary outer_params/outer_vars capture paths are unaffected by this subtraction.
+        let mut nested_bound = HashSet::new();
+        match body {
+            ArrowBody::Expr(e) => Self::collect_bound_names_deep_expr(e, &mut nested_bound),
+            ArrowBody::Block(s) => Self::collect_bound_names_deep(s, &mut nested_bound),
+        }
         let implicit_env_captures: Vec<String> = if self.value_fn_depth > 0 {
             referenced
                 .iter()
@@ -9851,6 +10484,13 @@ impl Codegen {
                     !param_names.contains(name.as_str())
                         && !local_var_names.contains(name.as_str())
                         && !already_captured.contains(name.as_str())
+                        && !nested_bound.contains(name.as_str())
+                        // #467: a native numeric GLOBAL (#176 TLS-lowered, e.g. `G_BASE`) has no
+                        // boxed binding anywhere — the body reads it via the thread-local — so a
+                        // capture emit here references a nonexistent ident (E0425 for any nested
+                        // arrow whose grandparent-scope var was TLS-lowered). Same exclusion the
+                        // FunDecl closure path and this fn's own outer_vars filter already apply.
+                        && !self.native_numeric_globals.contains_key(name.as_str())
                 })
                 .cloned()
                 .collect()
@@ -10264,7 +10904,7 @@ impl Codegen {
             }
         }
 
-        // Native typed-array HOFs (TISH_NATIVE_HOF): `xs.reduce/map/filter/some/every(<arrow>)`
+        // Native typed-array HOFs (default-on via native_opts_enabled): `xs.reduce/map/filter/some/every(<arrow>)`
         // whose native result type matches this binding's target → emit the iterator chain
         // directly, with NO box/unbox round-trip (the per-element `value_call` is gone too).
         if let Expr::Call { callee, args, .. } = expr {
@@ -10286,6 +10926,18 @@ impl Codegen {
             if &typed_ty == target_type {
                 return Ok(typed_code);
             }
+            // Integer-scalar target from a native numeric source (`let hp: u8 = 100`,
+            // `hp: dmg` where dmg is f64): truncate-cast directly instead of round-tripping
+            // through `Value::Number`. Covers narrow widths and `i32` uniformly.
+            if target_type.is_integer_scalar()
+                && (typed_ty == RustType::F64 || typed_ty.is_integer_scalar())
+            {
+                return Ok(format!("({}) as {}", typed_code, target_type.to_rust_type_str()));
+            }
+            // `f64` target from an integer-scalar source: widen directly.
+            if *target_type == RustType::F64 && typed_ty.is_integer_scalar() {
+                return Ok(format!("({}) as f64", typed_code));
+            }
         }
 
         // Fall back to emit_expr + conversion
@@ -11717,6 +12369,37 @@ impl Codegen {
         Ok(Some(assign))
     }
 
+    /// Emit `value` as a native expression of type `target_ty`, coercing without a
+    /// `Value` round-trip where the conversion is a cheap numeric cast. Same-typed RHS
+    /// passes through; f64↔i32 casts directly; everything else boxes to `Value` then
+    /// converts (correct for Fixed/String/Bool/Value fields, at one box per store).
+    fn emit_coerced_native(
+        &mut self,
+        value: &Expr,
+        target_ty: &RustType,
+    ) -> Result<String, CompileError> {
+        let (val_code, val_ty) = self.emit_typed_expr(value)?;
+        if val_ty == *target_ty {
+            return Ok(val_code);
+        }
+        // Cheap numeric coercions that avoid a `Value` round-trip: an integer scalar target
+        // truncate-casts a numeric RHS (`(v) as u8`), and an `f64` target widens an integer
+        // scalar RHS (`(v) as f64`). Covers i32↔f64 and every narrow width in one shape.
+        if target_ty.is_integer_scalar() && (val_ty == RustType::F64 || val_ty.is_integer_scalar())
+        {
+            return Ok(format!("({}) as {}", val_code, target_ty.to_rust_type_str()));
+        }
+        if *target_ty == RustType::F64 && val_ty.is_integer_scalar() {
+            return Ok(format!("({}) as f64", val_code));
+        }
+        let boxed = if val_ty.is_native() {
+            val_ty.to_value_expr(&val_code)
+        } else {
+            val_code
+        };
+        Ok(target_ty.from_value_expr(&boxed))
+    }
+
     /// `for (i=0; i<r; i++) { arr[i] = arr[i+1] }` → `arr.copy_within(1..(r+1), 0)` (fannkuch perm1 rotation).
     fn try_emit_vec_copy_within_shift_for(
         &mut self,
@@ -12357,6 +13040,24 @@ impl Codegen {
         }
     }
 
+    /// A numeric literal folded to a compile-time `Fixed` (Q24.8) constant, or `None` if `e`
+    /// isn't a plain number literal. Lets a `fixed ⊕ <literal>` op (`px + 1.5`, `hp * 2`) stay
+    /// native `Num<i32,8>` arithmetic instead of boxing the literal side through `f64`. Uses the
+    /// same truncating `(n * 256) as i32` conversion as the dynamic `fixed`↔`Value` boundary, so
+    /// the constant is bit-identical to the boxed path.
+    fn fixed_literal_of(e: &Expr) -> Option<String> {
+        if let Expr::Literal {
+            value: Literal::Number(n),
+            ..
+        } = e
+        {
+            let raw = (n * 256.0) as i32;
+            Some(format!("tishlang_runtime::Fixed::from_raw({}i32)", raw))
+        } else {
+            None
+        }
+    }
+
     /// Names of `f64` locals provably integer-bounded within `(-2^53, 2^53)` across the whole
     /// program. Seeds from integer-literal initializers and literal-bounded `for` counters, then
     /// runs a join fixpoint over reassignments: a local keeps a bound only if its init and EVERY
@@ -14277,6 +14978,9 @@ impl Codegen {
                     Expr::Member { optional: false, .. } | Expr::Index { optional: false, .. } => {
                         found = true
                     }
+                    // #437: a write to a frozen object throws a catchable TypeError (set_prop parks
+                    // it), so an assignment statement must checkpoint like a read/call does.
+                    Expr::MemberAssign { .. } | Expr::IndexAssign { .. } => found = true,
                     _ => {}
                 }
             });
@@ -14853,7 +15557,7 @@ impl Codegen {
 
     fn module_const_f64_array_as_value(static_name: &str) -> String {
         format!(
-            "Value::NumberArray(VmRef::new({}.iter().copied().collect::<Vec<f64>>()))",
+            "Value::NumberArray(VmRef::new(tishlang_runtime::NumArrayBacking::Packed({}.iter().copied().collect::<Vec<f64>>())))",
             static_name
         )
     }
@@ -16635,6 +17339,14 @@ impl Codegen {
             code
         } else if ty == RustType::Value {
             RustType::F64.from_value_expr(&code)
+        } else if ty.is_integer_scalar() {
+            // An integer scalar (`i32` or a narrow width) is exact in `f64` — widen it, rather
+            // than emitting the raw integer where an `f64` is required (e.g. `return total;`
+            // from a native-vec `-> f64` fn whose body yields an `i32` local).
+            format!("(({}) as f64)", code)
+        } else if ty == RustType::Fixed {
+            // Q24.8 → f64 (exact): raw / 256.
+            format!("(({}).to_raw() as f64 / 256.0)", code)
         } else {
             code
         })
@@ -17192,6 +17904,7 @@ impl Codegen {
                 name,
                 params,
                 rest_param: None,
+                return_type,
                 body,
                 ..
             } = s
@@ -17199,6 +17912,13 @@ impl Codegen {
                 if nonnumeric.contains(name.as_ref()) {
                     continue;
                 }
+                // The native-vec `_nv` lowering only expresses `f64`/`Vec<f64>`/unit returns
+                // (`VecRetKind`). A `fixed`-returning fn would be forced to `-> f64` while its
+                // body yields `Num<i32,8>` — a hard type error. Keep such fns on the (correct,
+                // boxed) dynamic path until `VecRetKind` learns `Fixed`.
+                if Self::ann_is_simple(return_type.as_ref(), "fixed") {
+                    continue;
+                }
                 if let Some(sig) = Self::infer_vec_fn_sig(params, body) {
                     let has_array_param = sig
                         .params
@@ -17237,6 +17957,7 @@ impl Codegen {
                     name,
                     params,
                     rest_param: None,
+                    return_type,
                     body,
                     ..
                 } = s
@@ -17250,6 +17971,11 @@ impl Codegen {
                     if nonnumeric.contains(name.as_ref()) {
                         continue;
                     }
+                    // A `fixed` return can't be expressed by `VecRetKind` (see the initial pass) — the
+                    // forwarding fixpoint must skip it too, or it re-adds the fn via `body_uses_local_vec_ops`.
+                    if Self::ann_is_simple(return_type.as_ref(), "fixed") {
+                        continue;
+                    }
                     if let Some(sig) = Self::infer_vec_fn_sig_forwarding(params, body, &sigs) {
                         let has_array_param = sig
                             .params
@@ -18698,7 +19424,7 @@ impl Codegen {
     // ====================================================================================
     // #177 (S-E / S-F): interprocedural aggregate (unboxed struct + Vec<Struct>) free fns.
     //
-    // The infer front-end (S-0..S-D, behind TISH_AGGREGATE_INFER) stamps a struct alias and
+    // The infer front-end (S-0..S-D, default-on via native_opts_enabled) stamps a struct alias and
     // `: alias` / `: alias[]` annotations onto the nbody-shape factory/array/operator fns iff a
     // whole-program candidacy predicate holds (monomorphic all-f64 struct, no `===`/escape/
     // reshape, write-permitting field ops). Here we consume that: emit each such fn as a native
@@ -18712,7 +19438,7 @@ impl Codegen {
     // identical to flag-off). So we never half-wire the feature or miscompile.
     // ====================================================================================
 
-    // ── #178: recursive-struct native lowering (behind TISH_REC_STRUCT) ─────────────────────
+    // ── #178: recursive-struct native lowering (default-on via native_opts_enabled) ─────────
     // Infers a recursive struct shape STRUCTURALLY (no identifier matching) from object literals
     // whose fields are scalars or recursive self-references, and emits native builders
     // (`name_rec(..) -> TishStruct_X`) + consumers (`name_rec(&TishStruct_X) -> f64`) over
@@ -21377,17 +22103,39 @@ impl Codegen {
                 // `emit_int32_operand`, which reads the i32 register directly. So coercing here only
                 // governs arithmetic/relational reads (e.g. the `h * 16777619` excursion), where the
                 // operand must be f64 to keep JS Number semantics.
-                let (l, lt) = if lt == RustType::I32 {
+                // A narrow int storage read (`u8` HP, `i16` tile x) promotes the same way — read
+                // as its exact `f64` value so arithmetic keeps JS Number semantics; the truncating
+                // store back to the field happens at the assignment site.
+                let (l, lt) = if lt.is_integer_scalar() {
                     (format!("(({}) as f64)", l), RustType::F64)
                 } else {
                     (l, lt)
                 };
-                let (r, rt) = if rt == RustType::I32 {
+                let (r, rt) = if rt.is_integer_scalar() {
                     (format!("(({}) as f64)", r), RustType::F64)
                 } else {
                     (r, rt)
                 };
 
+                // `fixed ⊕ <numeric-literal>` (`px + 1.5`, `hp * 2`, `y < 100.0`): fold the literal
+                // operand to a compile-time `Fixed` constant so the op lowers to native `Num<i32,8>`
+                // math via the `Fixed⊕Fixed` case below, instead of falling through to the boxed
+                // `ops::*` path. Only a plain literal is folded — a runtime `f64` still boxes (mixing
+                // a runtime f64 with fixed is genuinely lossy and stays on the safe dynamic path).
+                let (l, lt, r, rt) = if lt == RustType::Fixed && rt != RustType::Fixed {
+                    match Self::fixed_literal_of(right) {
+                        Some(fx) => (l, lt, fx, RustType::Fixed),
+                        None => (l, lt, r, rt),
+                    }
+                } else if rt == RustType::Fixed && lt != RustType::Fixed {
+                    match Self::fixed_literal_of(left) {
+                        Some(fx) => (fx, RustType::Fixed, r, rt),
+                        None => (l, lt, r, rt),
+                    }
+                } else {
+                    (l, lt, r, rt)
+                };
+
                 if let Some(result_ty) = RustType::result_type_of_binop(*op, &lt, &rt) {
                     // Bitwise/shift over numbers: lower the *whole* chain in the int32 domain so
                     // intermediate `to_int32`/`to_uint32`↔`f64` round-trips collapse (the win `>>>`
@@ -21866,7 +22614,7 @@ impl Codegen {
                         }
                     }
                 }
-                // Native typed-array HOFs over a `Vec<f64>` receiver (TISH_NATIVE_HOF):
+                // Native typed-array HOFs over a `Vec<f64>` receiver (default-on via native_opts_enabled):
                 // `xs.reduce/map/filter/some/every(<arrow>)` → a direct Rust iterator chain,
                 // eliminating the per-element `value_call` and all `Value` boxing.
                 if let Some(res) = self.native_vec_hof_for_call(callee, args)? {
@@ -22082,16 +22830,25 @@ impl Codegen {
             None
         };
         if let Some(nat_op) = nat_op {
+            // #508: a packed `Value::NumberArray` receiver (e.g. `new Float64Array([…])` under
+            // TISH_PACKED_ARRAYS=1) must fold too — the old `if let Value::Array … else init`
+            // silently returned the INIT for it. Its elements are raw f64 by construction, so the
+            // packed arm is the pure-f64 fold with zero boxing; a non-Number init falls back to
+            // the boxed fold over `Value::Number` elements (identical semantics).
             return Ok(Some(format!(
                 "{{ let _init0 = {init}; let _arr = ({obj}).clone(); \
-                 if let Value::Array(ref _a) = _arr {{ let _b = _a.borrow(); \
+                 match _arr {{ Value::Array(ref _a) => {{ let _b = _a.borrow(); \
                  let mut _accn: f64 = 0.0; let mut _ok = false; \
                  if let Value::Number(_i0) = &_init0 {{ _accn = *_i0; _ok = true; }} \
                  if _ok {{ for _el in _b.iter() {{ \
                  if let Value::Number(_n) = _el {{ _accn {nat_op} *_n; }} else {{ _ok = false; break; }} }} }} \
                  if _ok {{ Value::Number(_accn) }} \
                  else {{ let mut _acc = _init0; for _el in _b.iter() {{ let _x = _el.clone(); _acc = {body}; }} _acc }} \
-                 }} else {{ _init0 }} }}",
+                 }}, Value::NumberArray(ref _a) => {{ let _vals = _a.borrow().to_values(); \
+                 if let (true, Value::Number(_i0)) = (_a.borrow().as_packed().is_some(), &_init0) {{ let mut _accn: f64 = *_i0; \
+                 for _v in &_vals {{ if let Value::Number(_n) = _v {{ _accn {nat_op} *_n; }} }} Value::Number(_accn) }} \
+                 else {{ let mut _acc = _init0; for _x in _vals {{ _acc = {body}; }} _acc }} \
+                 }}, _ => _init0 }} }}",
                 init = initial,
                 obj = obj_expr,
                 nat_op = nat_op,
@@ -22099,10 +22856,13 @@ impl Codegen {
             )));
         }
 
+        // #508: same NumberArray arm for the general (non-arithmetic-op) fold.
         Ok(Some(format!(
             "{{ let mut _acc = {init}; let _arr = ({obj}).clone(); \
-             if let Value::Array(ref _a) = _arr {{ for _el in _a.borrow().iter() {{ \
-             let _x = _el.clone(); _acc = {body}; }} }} _acc }}",
+             match _arr {{ Value::Array(ref _a) => {{ for _el in _a.borrow().iter() {{ \
+             let _x = _el.clone(); _acc = {body}; }} }} \
+             Value::NumberArray(ref _a) => {{ for _x in _a.borrow().to_values() {{ \
+             _acc = {body}; }} }} _ => {{}} }} _acc }}",
             init = initial,
             obj = obj_expr,
             body = body_code
@@ -22595,7 +23355,7 @@ impl Codegen {
                     "let mut __out: Vec<f64> = Vec::new(); \
                      for &__f0 in __na.iter() {{ let mut __f = __f0; {inner} \
                      let {p}: f64 = __f; __out.push({term}); }} \
-                     Value::NumberArray(VmRef::new(__out))",
+                     Value::NumberArray(VmRef::new(tishlang_runtime::NumArrayBacking::Packed(__out)))",
                     inner = inner, p = pesc, term = term
                 )
             }
@@ -22607,7 +23367,7 @@ impl Codegen {
                     "let mut __out: Vec<f64> = Vec::new(); \
                      for &__f0 in __na.iter() {{ let mut __f = __f0; {inner} \
                      let {p}: f64 = __f; if {pred} {{ __out.push({p}); }} }} \
-                     Value::NumberArray(VmRef::new(__out))",
+                     Value::NumberArray(VmRef::new(tishlang_runtime::NumArrayBacking::Packed(__out)))",
                     inner = inner, p = pesc, pred = pred
                 )
             }
@@ -22617,7 +23377,7 @@ impl Codegen {
     }
 
     /// If `callee(args)` is `<Vec<f64>-ident>.reduce/map/filter/some/every(<arrow>)` and the
-    /// `TISH_NATIVE_HOF` flag is set, lower it to a native iterator chain. Shared by
+    /// native opts are enabled (default-on), lower it to a native iterator chain. Shared by
     /// `emit_typed_expr` (native sub-expressions) and `emit_native_expr` (typed `let` RHS), so a
     /// typed-array HOF lowers natively whether its result flows into arithmetic or a binding.
     fn native_vec_hof_for_call(
@@ -22654,7 +23414,7 @@ impl Codegen {
         self.try_native_vec_hof(&recv_code, &inner, recv_name.as_ref(), method.as_ref(), args)
     }
 
-    /// Native typed-array HOFs (`TISH_NATIVE_HOF`): when the receiver is a native `Vec<f64>`
+    /// Native typed-array HOFs (default-on via `native_opts_enabled`): when the receiver is a native `Vec<f64>`
     /// (a typed `number[]`), lower `reduce`/`map`/`filter`/`some`/`every` to a direct Rust
     /// iterator chain — no per-element `value_call`, no `Value` boxing.
     ///