@tishlang/tish-lsp 3.0.0 → 3.1.0

package/crates/tish/tests/scope_merge.rs

@@ -77,3 +77,34 @@ fn scope_exports_tish_merges_as_source() {
 fn scope_plain_main_merges_as_source() {
     assert_merged_as_source(&setup(r#","main":"index.tish""#));
 }
+
+/// The other half of the #38 split: a `@scope/pkg` that opts in via `tish.crate` (the tish-apple
+/// hosts, published as `@tishlang/tish-macos` / `@tishlang/tish-ios`) routes to the NATIVE path —
+/// lowered to `NativeModuleLoad`, not merged as source.
+#[test]
+fn scope_tish_crate_routes_native() {
+    let dir = setup(r#","tish":{"module":true,"crate":"test-greet","export":"greet_object"}"#);
+    let root = dir.path();
+    let modules = resolve_project(&root.join("main.tish"), Some(root)).expect("resolve");
+    let merged = merge_modules(modules).expect("merge");
+    let native_scope = merged.program.statements.iter().any(|s| {
+        matches!(
+            s,
+            Statement::VarDecl { init: Some(Expr::NativeModuleLoad { spec, .. }), .. }
+            if spec.as_ref() == "@test/greet"
+        )
+    });
+    assert!(
+        native_scope,
+        "@scope package with tish.crate must lower to NativeModuleLoad (native Rust-crate path)"
+    );
+    let has_greet = merged
+        .program
+        .statements
+        .iter()
+        .any(|s| matches!(s, Statement::FunDecl { name, .. } if name.as_ref() == "greet"));
+    assert!(
+        !has_greet,
+        "@scope package with tish.crate must NOT be merged as Tish source"
+    );
+}

package/crates/tish_build_utils/src/lib.rs

@@ -3,10 +3,11 @@
 //! Provides workspace discovery, path resolution, and Cargo build orchestration
 //! used by tishlang_wasm, tishlang_cranelift, tishlang_native, and the tish CLI.
 
+use std::collections::BTreeSet;
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 /// Serialize nested `cargo build` calls that share the workspace `target/` dir (tests + `tish build`).
 static NESTED_CARGO_MUTEX: Mutex<()> = Mutex::new(());
@@ -19,6 +20,56 @@ fn mold_available() -> bool {
         .unwrap_or(false)
 }
 
+/// The `target_feature="..."` values in `rustc --print cfg` output.
+fn parse_target_features(print_cfg_stdout: &str) -> BTreeSet<String> {
+    print_cfg_stdout
+        .lines()
+        .filter_map(|l| l.trim().strip_prefix("target_feature=\""))
+        .filter_map(|l| l.strip_suffix('"'))
+        .map(str::to_owned)
+        .collect()
+}
+
+/// Host target features rustc reports, optionally under one extra `-C` flag.
+fn rustc_target_features(codegen_flag: Option<&str>) -> Option<BTreeSet<String>> {
+    let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string());
+    let mut cmd = Command::new(rustc);
+    cmd.args(["--print", "cfg"]);
+    if let Some(flag) = codegen_flag {
+        cmd.args(["-C", flag]);
+    }
+    let out = cmd.output().ok()?;
+    if !out.status.success() {
+        return None;
+    }
+    Some(parse_target_features(&String::from_utf8_lossy(&out.stdout)))
+}
+
+/// True when `-C target-cpu=native` is worth passing on this host.
+///
+/// `native` asks LLVM to identify the host core. On hosts it cannot identify — notably
+/// the virtualized Apple Silicon behind GitHub Actions' macOS runners — it answers
+/// `generic`, which is *narrower* than the target's own default CPU. On
+/// aarch64-apple-darwin that silently drops `aes` and `sha2`, and crates that assert
+/// those are statically present then fail to compile at all; `ring` 0.17 trips
+/// `assertion failed: CAPS_STATIC == MIN_STATIC_FEATURES` in const-eval.
+///
+/// So this compares feature sets rather than trusting `native` blindly: keep the flag
+/// only when it is a strict win (every default feature survives). If rustc cannot be
+/// queried, skip the flag — the target default is always correct, just less tuned.
+fn native_target_cpu_is_safe() -> bool {
+    static SAFE: OnceLock<bool> = OnceLock::new();
+    *SAFE.get_or_init(|| {
+        match (
+            rustc_target_features(None),
+            rustc_target_features(Some("target-cpu=native")),
+        ) {
+            (Some(default), Some(native)) => default.is_subset(&native),
+            _ => false,
+        }
+    })
+}
+
 /// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
 ///
 /// Used so we do not treat unrelated workspaces (e.g. a parent `zectre-platform` repo) as Tish
@@ -347,7 +398,13 @@ pub fn cargo_target_name(stem: &str) -> String {
     // A leading digit is prefixed with `_`; an empty result falls back to a fixed default.
     let mut name: String = stem
         .chars()
-        .map(|c| if c.is_ascii_alphanumeric() || c == '_' { c } else { '_' })
+        .map(|c| {
+            if c.is_ascii_alphanumeric() || c == '_' {
+                c
+            } else {
+                '_'
+            }
+        })
         .collect();
     if name.is_empty() {
         return "tish_output".to_string();
@@ -371,6 +428,10 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
 }
 
 /// Run cargo build in the given directory.
+///
+/// `-C target-cpu=native` is added only for host builds, only when the caller has not
+/// already pinned a `target-cpu` in `RUSTFLAGS`, and only when `native` does not lose
+/// target features against the target default (see `native_target_cpu_is_safe`).
 /// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
 pub fn run_cargo_build(
     build_dir: &Path,
@@ -395,10 +456,14 @@ pub fn run_cargo_build(
             merged_rustflags = format!("{} -C link-arg=-fuse-ld=mold", merged_rustflags.trim());
             merged_rustflags = merged_rustflags.trim().to_string();
         }
-    } else if merged_rustflags.is_empty() {
-        merged_rustflags = "-C target-cpu=native".to_string();
-    } else if !merged_rustflags.contains("target-cpu") {
-        merged_rustflags = format!("{} -C target-cpu=native", merged_rustflags);
+    } else if !merged_rustflags.contains("target-cpu") && native_target_cpu_is_safe() {
+        // Caller did not pin a CPU and `native` resolves to something at least as
+        // capable as the target default — see `native_target_cpu_is_safe`.
+        merged_rustflags = if merged_rustflags.is_empty() {
+            "-C target-cpu=native".to_string()
+        } else {
+            format!("{} -C target-cpu=native", merged_rustflags)
+        };
     }
 
     let mut cmd = Command::new("cargo");
@@ -438,6 +503,66 @@ pub fn run_cargo_build(
 mod protoc_tests {
     use super::*;
 
+    /// Trimmed `rustc --print cfg --target aarch64-apple-darwin`.
+    const APPLE_DARWIN_DEFAULT_CFG: &str = r#"
+debug_assertions
+panic="unwind"
+target_arch="aarch64"
+target_feature="aes"
+target_feature="neon"
+target_feature="sha2"
+target_feature="sha3"
+target_os="macos"
+"#;
+
+    #[test]
+    fn parses_target_features_from_print_cfg() {
+        let features = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        assert_eq!(
+            features.iter().map(String::as_str).collect::<Vec<_>>(),
+            ["aes", "neon", "sha2", "sha3"]
+        );
+        // Non-`target_feature` keys never leak in, and neither do the quotes.
+        assert!(!features.contains("aarch64"));
+        assert!(!features.contains("\"aes\""));
+    }
+
+    #[test]
+    fn native_cpu_rejected_when_it_drops_target_features() {
+        // What GitHub's virtualized Apple Silicon reports: `native` -> `generic`, which
+        // keeps only `neon`. Pinning it would break `ring`'s static feature assertions.
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let generic = parse_target_features("target_feature=\"neon\"\n");
+        assert!(!default.is_subset(&generic));
+    }
+
+    #[test]
+    fn native_cpu_accepted_when_it_only_adds() {
+        let default = parse_target_features(APPLE_DARWIN_DEFAULT_CFG);
+        let apple_m1 = parse_target_features(
+            "target_feature=\"aes\"\ntarget_feature=\"neon\"\n\
+             target_feature=\"sha2\"\ntarget_feature=\"sha3\"\ntarget_feature=\"lse\"\n",
+        );
+        assert!(default.is_subset(&apple_m1));
+        // Identical sets count as safe too — `native` matching the default is a no-op.
+        assert!(default.is_subset(&default));
+    }
+
+    #[test]
+    fn live_rustc_probe_still_parses() {
+        // Guards the parse against a `rustc --print cfg` format change: every target Tish
+        // builds on has at least one baseline target feature (x86_64 sse2, aarch64 neon).
+        // If this ever comes back empty the probe would silently disable target-cpu=native
+        // everywhere rather than only on hosts LLVM cannot identify.
+        let Some(features) = rustc_target_features(None) else {
+            return; // no rustc on PATH — nothing to assert
+        };
+        assert!(
+            !features.is_empty(),
+            "no target_feature in rustc --print cfg"
+        );
+    }
+
     #[test]
     fn cargo_target_name_replaces_hyphens() {
         assert_eq!(cargo_target_name("hello-ios"), "hello_ios");

package/crates/tish_compile/src/codegen.rs

@@ -1018,6 +1018,9 @@ pub(crate) struct Codegen {
     features: std::collections::HashSet<String>,
     /// spec -> native init strategy (legacy adapter object vs generated `generated_native` wrapper)
     native_module_init: std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
+    /// spec -> the `run()`-local holding that module's namespace object, bound ONCE in the preamble.
+    /// Building it is O(exports) — see `emit_native_namespace_preamble`.
+    native_ns_locals: std::collections::HashMap<String, String>,
     /// Typed native imports (`declare fun` + a native import): tish name -> its typed signature.
     /// A matching call emits a DIRECT `<crate>::name_typed(..)` instead of a boxed `value_call`.
     extern_fns: std::collections::HashMap<String, ExternSig>,
@@ -1292,6 +1295,7 @@ impl Codegen {
             string_charset: String::new(),
             features,
             native_module_init,
+            native_ns_locals: std::collections::HashMap::new(),
             extern_fns: std::collections::HashMap::new(),
             user_fn_returns: std::collections::HashMap::new(),
             async_context_stack: Vec::new(),
@@ -2044,6 +2048,48 @@ impl Codegen {
         }
     }
 
+    /// The Rust expression that CONSTRUCTS a native module's namespace object. O(exports): it inserts
+    /// every function the crate exports into a fresh map. Call it once per module, not once per import.
+    fn native_module_ns_ctor(init: &crate::resolve::NativeModuleInit) -> String {
+        match init {
+            crate::resolve::NativeModuleInit::Legacy {
+                crate_name,
+                export_fn,
+            } => format!("{}::{}()", crate_name, export_fn),
+            crate::resolve::NativeModuleInit::Generated { export_fn, .. } => {
+                format!("crate::generated_native::{}()", export_fn)
+            }
+        }
+    }
+
+    /// Bind every native module's namespace object to a `run()`-local, ONCE, before any import reads
+    /// from one.
+    ///
+    /// Each named import lowers to "get this key out of the module's namespace". Building that
+    /// namespace is O(exports) — a fresh `ObjectMap` with an `Arc<str>` key and a native closure per
+    /// exported function — so doing it at every import site is O(imports x exports): importing 68
+    /// names from a crate that exports 68 cost 4,624 allocations to bind 68 functions. On a GBA that
+    /// was measured at 3 seconds of black screen (`tish-gba/examples/bench-boot`), paid before the
+    /// program's first statement; `packages/engine.tish` there imports 117 symbols across two crates
+    /// and cost 4.3s. Hoisting makes it O(imports + exports).
+    ///
+    /// Emitted in sorted order so the generated Rust is byte-identical across builds (the map is a
+    /// `HashMap`, whose iteration order is not).
+    fn emit_native_namespace_preamble(&mut self) {
+        let mut specs: Vec<String> = self.native_module_init.keys().cloned().collect();
+        specs.sort();
+        for (i, spec) in specs.iter().enumerate() {
+            // Index rather than a sanitized spec: `cargo:a-b` and `cargo:a_b` sanitize to the same
+            // identifier, and silently binding one module's namespace under another's name would be a
+            // very quiet bug.
+            let local = format!("__tish_native_ns_{}", i);
+            let ctor = Self::native_module_ns_ctor(&self.native_module_init[spec]);
+            // A module can be resolved but have every one of its imports shadowed or unused.
+            self.writeln(&format!("#[allow(unused_variables)] let {} = {};", local, ctor));
+            self.native_ns_locals.insert(spec.clone(), local);
+        }
+    }
+
     /// Map native module spec to Rust init expression using resolved package.json modules.
     /// For built-in modules (tish:fs, tish:http, tish:process), use builtin_native_module_rust_init.
     fn native_module_rust_init(&self, spec: &str, export_name: &str) -> Option<String> {
@@ -2053,19 +2099,18 @@ impl Codegen {
         self.native_module_init.get(spec).map(|init| {
             // Native modules return a namespace object (like an ES module).
             // Named imports extract the field from that namespace: `import { foo } from "pkg"` → `ns.foo`.
-            let init_expr = match init {
-                crate::resolve::NativeModuleInit::Legacy {
-                    crate_name,
-                    export_fn,
-                } => format!("{}::{}()", crate_name, export_fn),
-                crate::resolve::NativeModuleInit::Generated { export_fn, .. } => {
-                    format!("crate::generated_native::{}()", export_fn)
-                }
-            };
-            format!(
-                "{{ let _ns = {}; match _ns {{ Value::Object(ref _o) => _o.borrow().strings.get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
-                init_expr, export_name
-            )
+            // Read it from the hoisted local when there is one; the inline constructor is the fallback
+            // for anything emitted outside `run()`'s preamble.
+            match self.native_ns_locals.get(spec) {
+                Some(local) => format!(
+                    "{{ match &{} {{ Value::Object(ref _o) => _o.borrow().strings.get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
+                    local, export_name
+                ),
+                None => format!(
+                    "{{ let _ns = {}; match _ns {{ Value::Object(ref _o) => _o.borrow().strings.get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
+                    Self::native_module_ns_ctor(init), export_name
+                ),
+            }
         })
     }
 
@@ -2098,6 +2143,7 @@ impl Codegen {
                     "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))"),
+                    "chmod" | "chmodSync" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::chmod(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))"),
@@ -2121,6 +2167,7 @@ impl Codegen {
                     "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))"),
+                    "chmod" => Some("Value::native(|args: &[Value]| tishlang_runtime::fs_ext::chmod_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))"),
@@ -2155,9 +2202,20 @@ impl Codegen {
                     "execFile" => Some("Value::native(|args: &[Value]| tish_process_exec_file(args))"),
                     "execCapture" => Some("Value::native(|args: &[Value]| tish_process_exec_capture(args))"),
                     "execFileCapture" => Some("Value::native(|args: &[Value]| tish_process_exec_file_capture(args))"),
+                    "spawn" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_spawn(args))"),
+                    "readStdout" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_read_stdout(args))"),
+                    "readStderr" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_read_stderr(args))"),
+                    "writeStdin" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_write_stdin(args))"),
+                    "closeStdin" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_close_stdin(args))"),
+                    "wait" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_wait(args))"),
+                    "kill" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_kill(args))"),
+                    "pid" => Some("Value::native(|args: &[Value]| tishlang_runtime::process_pid(args))"),
                     "argv" => Some("Value::Array(VmRef::new(std::env::args().map(|s| Value::String(s.into())).collect()))"),
                     "env" => Some("Value::object(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect())"),
-                    "process" => Some("{ let mut m = ObjectMap::default(); m.insert(Arc::from(\"exit\"), Value::native(|args: &[Value]| tish_process_exit(args))); m.insert(Arc::from(\"cwd\"), Value::native(|args: &[Value]| tish_process_cwd(args))); m.insert(Arc::from(\"exec\"), Value::native(|args: &[Value]| tish_process_exec(args))); m.insert(Arc::from(\"execFile\"), Value::native(|args: &[Value]| tish_process_exec_file(args))); m.insert(Arc::from(\"execCapture\"), Value::native(|args: &[Value]| tish_process_exec_capture(args))); m.insert(Arc::from(\"execFileCapture\"), Value::native(|args: &[Value]| tish_process_exec_file_capture(args))); m.insert(Arc::from(\"argv\"), Value::Array(VmRef::new(std::env::args().map(|s| Value::String(s.into())).collect()))); m.insert(Arc::from(\"env\"), Value::object(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect::<ObjectMap>())); Value::object(m) }"),
+                    // Node-style platform string so `process.platform` reads identically on the JS
+                    // target (Node's real global) and native (this): macos->darwin, windows->win32.
+                    "platform" => Some("Value::String(match std::env::consts::OS { \"macos\" => \"darwin\", \"windows\" => \"win32\", o => o }.into())"),
+                    "process" => Some("{ let mut m = ObjectMap::default(); m.insert(Arc::from(\"exit\"), Value::native(|args: &[Value]| tish_process_exit(args))); m.insert(Arc::from(\"cwd\"), Value::native(|args: &[Value]| tish_process_cwd(args))); m.insert(Arc::from(\"exec\"), Value::native(|args: &[Value]| tish_process_exec(args))); m.insert(Arc::from(\"execFile\"), Value::native(|args: &[Value]| tish_process_exec_file(args))); m.insert(Arc::from(\"execCapture\"), Value::native(|args: &[Value]| tish_process_exec_capture(args))); m.insert(Arc::from(\"execFileCapture\"), Value::native(|args: &[Value]| tish_process_exec_file_capture(args))); m.insert(Arc::from(\"argv\"), Value::Array(VmRef::new(std::env::args().map(|s| Value::String(s.into())).collect()))); m.insert(Arc::from(\"env\"), Value::object(std::env::vars().map(|(k,v)| (Arc::from(k.as_str()), Value::String(v.into()))).collect::<ObjectMap>())); m.insert(Arc::from(\"platform\"), Value::String(match std::env::consts::OS { \"macos\" => \"darwin\", \"windows\" => \"win32\", o => o }.into())); Value::object(m) }"),
                     _ => None,
                 },
             "tish:ws" if self.has_feature("ws") => match export_name {
@@ -2187,6 +2245,37 @@ impl Codegen {
                     "pid" => Some("Value::native(|args: &[Value]| tishlang_runtime::pty_pid(args))"),
                     _ => None,
                 },
+            "tish:net" if self.has_feature("net") => match export_name {
+                    "connect" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_connect(args))"),
+                    "read" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_read(args))"),
+                    "write" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_write(args))"),
+                    "close" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_close(args))"),
+                    "listen" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_listen(args))"),
+                    "accept" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_accept(args))"),
+                    "probe" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_probe(args))"),
+                    "sleep" => Some("Value::native(|args: &[Value]| tishlang_runtime::net_sleep(args))"),
+                    _ => None,
+                },
+            "tish:encoding" if self.has_feature("encoding") => match export_name {
+                    "base64Encode" => Some("Value::native(|args: &[Value]| tishlang_runtime::base64_encode(args))"),
+                    "base64Decode" => Some("Value::native(|args: &[Value]| tishlang_runtime::base64_decode(args))"),
+                    "base64UrlEncode" => Some("Value::native(|args: &[Value]| tishlang_runtime::base64_url_encode(args))"),
+                    "base64UrlDecode" => Some("Value::native(|args: &[Value]| tishlang_runtime::base64_url_decode(args))"),
+                    "utf8Decode" => Some("Value::native(|args: &[Value]| tishlang_runtime::utf8_decode(args))"),
+                    "utf8Encode" => Some("Value::native(|args: &[Value]| tishlang_runtime::utf8_encode(args))"),
+                    _ => None,
+                },
+            "tish:crypto" if self.has_feature("crypto") => match export_name {
+                    "sha256" => Some("Value::native(|args: &[Value]| tishlang_runtime::sha256(args))"),
+                    "sha256Hex" => Some("Value::native(|args: &[Value]| tishlang_runtime::sha256_hex(args))"),
+                    "randomBytes" => Some("Value::native(|args: &[Value]| tishlang_runtime::random_bytes(args))"),
+                    _ => None,
+                },
+            "tish:zip" if self.has_feature("zip") => match export_name {
+                    "extract" => Some("Value::native(|args: &[Value]| tishlang_runtime::zip_extract(args))"),
+                    "entries" => Some("Value::native(|args: &[Value]| tishlang_runtime::zip_entries(args))"),
+                    _ => None,
+                },
             _ => return None,
         };
         init.map(String::from)
@@ -2196,7 +2285,8 @@ impl Codegen {
         if self.features.contains("full") {
             matches!(
                 name,
-                "http" | "timers" | "fs" | "process" | "regex" | "ws" | "tty" | "pty"
+                "http" | "timers" | "fs" | "process" | "regex" | "ws" | "tty" | "pty" | "net"
+                    | "encoding" | "crypto" | "zip"
             )
         } else {
             self.features.contains(name)
@@ -3088,6 +3178,9 @@ impl Codegen {
         }
         self.indent += 1;
 
+        // Before anything else: one namespace object per native module, shared by all of its imports.
+        self.emit_native_namespace_preamble();
+
         // Initialize builtins
         self.writeln("let mut console = Value::object(ObjectMap::from([");
         self.indent += 1;
@@ -3331,6 +3424,9 @@ impl Codegen {
             self.indent -= 1;
             self.writeln("}");
             self.writeln("p.insert(Arc::from(\"env\"), Value::object(env_obj));");
+            // Node-style platform string (macos->darwin, windows->win32) so bare `process.platform`
+            // matches the JS target's Node global and the named `tish:process` export.
+            self.writeln("p.insert(Arc::from(\"platform\"), Value::String(match std::env::consts::OS { \"macos\" => \"darwin\", \"windows\" => \"win32\", o => o }.into()));");
             self.writeln("p");
             self.indent -= 1;
             self.writeln("});");
@@ -3612,9 +3708,17 @@ impl Codegen {
                         let escaped = Self::escape_ident(name.as_ref());
                         return Ok(format!("{} = ({}) as i32", escaped, int_code));
                     }
+                    let (val_code, val_ty) = self.emit_typed_expr(value)?;
+                    // An RHS that is ALREADY an integer stores straight into the register. `d = d + 1`
+                    // reaches here — it is arithmetic, not a bitwise chain, so `emit_int32_operand`
+                    // declines it — and boxing that i32 into a `Value::Number` only to run ToInt32 back
+                    // out of it was the whole cost of incrementing an annotated counter.
+                    let escaped_int = Self::escape_ident(name.as_ref());
+                    if val_ty.is_integer_scalar() {
+                        return Ok(format!("{} = ({}) as i32", escaped_int, val_code));
+                    }
                     // Defensive: gate guarantees `Some`, but if a future RHS shape slips through,
                     // fall back to a sound f64-narrowed store rather than miscompiling.
-                    let (val_code, val_ty) = self.emit_typed_expr(value)?;
                     let v = if val_ty.is_native() {
                         val_ty.to_value_expr(&val_code)
                     } else {
@@ -14083,6 +14187,22 @@ impl Codegen {
     /// 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.
+    /// A numeric literal that is EXACTLY a whole number inside `i32`'s range, as an `i32`. Used to keep
+    /// `x > 0` / `i < 100` in integer registers when the other side is already an integer — a fraction
+    /// or an out-of-range magnitude returns `None` and stays on the `f64` path, where it is correct.
+    fn int_literal_of(e: &Expr) -> Option<i32> {
+        if let Expr::Literal {
+            value: Literal::Number(n),
+            ..
+        } = e
+        {
+            if n.fract() == 0.0 && *n >= i32::MIN as f64 && *n <= i32::MAX as f64 {
+                return Some(*n as i32);
+            }
+        }
+        None
+    }
+
     fn fixed_literal_of(e: &Expr) -> Option<String> {
         if let Expr::Literal {
             value: Literal::Number(n),
@@ -23161,6 +23281,83 @@ impl Codegen {
                 // 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.
+                // …but when BOTH sides are already integers, that detour is pure loss on a CPU with no
+                // FPU. On ARM7TDMI every f64 op is a soft-float library CALL, so `i + 1` on a `: i32`
+                // counter costs two int→float conversions, a call, and a float→int store. It is why
+                // annotating a loop counter `: i32` measured SLOWER than leaving it a plain number
+                // (examples/bench-ai) — the opposite of what an annotation is for.
+                //
+                // Keeping the pair in integer registers is not an approximation: every i32 is exact in
+                // f64, so `+`, `-` and the relational operators give bit-identical answers in either
+                // domain. Only the operators where the two domains genuinely DISAGREE stay on floats:
+                //   `/`  JS division is real division — `5 / 2` is 2.5, not 2
+                //   `%`  integer `%` panics on a zero divisor where JS yields NaN
+                //   `*`  a product can leave i32's range while staying exact in f64, and the bitwise
+                //        lowering below deliberately relies on that headroom (`h * 16777619`)
+                // Operands widen to `i32` first so mixed widths (a `u8` HP against an `i16` tile
+                // coordinate) still agree with JS Number semantics. `u32` is excluded because it is the
+                // one width that does not fit — reading 3 billion `as i32` would flip its sign.
+                // The adds wrap rather than panic, which matches both JS (`to_int32` is modulo 2³²) and
+                // the truncating `as` store every integer target already performs.
+                let fits_i32 = |t: &RustType| {
+                    matches!(
+                        t,
+                        RustType::I32
+                            | RustType::I8
+                            | RustType::U8
+                            | RustType::I16
+                            | RustType::U16
+                    )
+                };
+                // An integer against a whole-number LITERAL is the shape most of this actually is —
+                // `x > 0`, `i < 100`, `0 - dir`. The literal types as `f64`, which would drag the
+                // integer side out of its register for a soft-float compare over two values that are
+                // both plainly integers. Fold it into the integer domain instead. Only exact whole
+                // numbers inside i32's range qualify, so `x < 2.5` and `x < 3e9` still go to floats,
+                // where they belong.
+                let (l, lt, r, rt) = if fits_i32(&lt) && rt == RustType::F64 {
+                    match Self::int_literal_of(right) {
+                        Some(v) => (l, lt, format!("{}i32", v), RustType::I32),
+                        None => (l, lt, r, rt),
+                    }
+                } else if fits_i32(&rt) && lt == RustType::F64 {
+                    match Self::int_literal_of(left) {
+                        Some(v) => (format!("{}i32", v), RustType::I32, r, rt),
+                        None => (l, lt, r, rt),
+                    }
+                } else {
+                    (l, lt, r, rt)
+                };
+                if fits_i32(&lt) && fits_i32(&rt) {
+                    let li = format!("(({}) as i32)", l);
+                    let ri = format!("(({}) as i32)", r);
+                    match op {
+                        BinOp::Add => {
+                            return Ok((
+                                format!("({}).wrapping_add({})", li, ri),
+                                RustType::I32,
+                            ))
+                        }
+                        BinOp::Sub => {
+                            return Ok((
+                                format!("({}).wrapping_sub({})", li, ri),
+                                RustType::I32,
+                            ))
+                        }
+                        BinOp::Lt => return Ok((format!("({} < {})", li, ri), RustType::Bool)),
+                        BinOp::Le => return Ok((format!("({} <= {})", li, ri), RustType::Bool)),
+                        BinOp::Gt => return Ok((format!("({} > {})", li, ri), RustType::Bool)),
+                        BinOp::Ge => return Ok((format!("({} >= {})", li, ri), RustType::Bool)),
+                        BinOp::StrictEq => {
+                            return Ok((format!("({} == {})", li, ri), RustType::Bool))
+                        }
+                        BinOp::StrictNe => {
+                            return Ok((format!("({} != {})", li, ri), RustType::Bool))
+                        }
+                        _ => {}
+                    }
+                }
+
                 let (l, lt) = if lt.is_integer_scalar() {
                     (format!("(({}) as f64)", l), RustType::F64)
                 } else {

package/crates/tish_compile/src/resolve.rs

@@ -77,6 +77,10 @@ const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("ws", "tish:ws"),
     ("tty", "tish:tty"),
     ("pty", "tish:pty"),
+    ("net", "tish:net"),
+    ("encoding", "tish:encoding"),
+    ("crypto", "tish:crypto"),
+    ("zip", "tish:zip"),
 ];
 
 /// Normalize built-in spec to canonical form. Handles the Node `node:` prefix
@@ -106,9 +110,14 @@ pub fn is_builtin_native_spec(spec: &str) -> bool {
             | "tish:ws"
             | "tish:tty"
             | "tish:pty"
+            | "tish:net"
+            | "tish:encoding"
+            | "tish:crypto"
+            | "tish:zip"
     ) || matches!(
         spec,
-        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "pty"
+        "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "pty" | "net"
+            | "encoding" | "crypto" | "zip"
     )
 }
 
@@ -1029,7 +1038,8 @@ pub fn is_native_import(spec: &str) -> bool {
         || spec.starts_with("ffi:")
         || matches!(
             spec,
-            "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty"
+            "fs" | "fs/promises" | "http" | "timers" | "process" | "ws" | "tty" | "net" | "encoding"
+                | "crypto" | "zip"
         )
 }
 

package/crates/tish_core/src/shape.rs

@@ -12,9 +12,9 @@
 //! `PropMap` on a cache miss). Phase 1b will attach the ordered key list to each shape so objects can
 //! drop per-object key storage entirely (the butterfly representation).
 
-use crate::compat::{AHashMap, Arc, OnceLock, RwLock};
-#[cfg(feature = "portable")]
-use alloc::{vec, vec::Vec};
+use crate::compat::Arc;
+#[cfg(not(feature = "portable"))]
+use crate::compat::{AHashMap, OnceLock, RwLock};
 
 /// Identity of an object's ordered key-set.
 pub type ShapeId = u32;
@@ -31,15 +31,18 @@ pub const DICT_SHAPE: ShapeId = u32::MAX;
 /// Edges are keyed by an `ahash` map, not the default SipHash one: `transition` is on the hot path of
 /// every object construction (and `JSON.parse` — profiled as ~16% of parse, almost all SipHash), and
 /// ahash is ~2–3× faster on short string keys. Random-seeded per process, so no HashDoS regression.
+#[cfg(not(feature = "portable"))]
 #[derive(Default)]
 struct ShapeNode {
     transitions: AHashMap<Arc<str>, ShapeId>,
 }
 
+#[cfg(not(feature = "portable"))]
 struct Registry {
     nodes: Vec<ShapeNode>,
 }
 
+#[cfg(not(feature = "portable"))]
 fn registry() -> &'static RwLock<Registry> {
     static REG: OnceLock<RwLock<Registry>> = OnceLock::new();
     REG.get_or_init(|| {
@@ -56,6 +59,28 @@ fn registry() -> &'static RwLock<Registry> {
 /// object with the same construction path reuses it. Cheap on the hot path (a read-lock + one hashmap
 /// lookup once the edge exists). A `DICT_SHAPE` input (or shape-space exhaustion) stays `DICT_SHAPE`.
 pub fn transition(from: ShapeId, key: &Arc<str>) -> ShapeId {
+    // On `portable` (the embedded/GBA link) nothing ever READS a shape id: the only consumers are
+    // the bytecode VM (`tish_vm`) and the std runtime's inline caches (`tish_runtime`), and neither
+    // is linked there — the GBA facade's `get_prop` goes straight to `PropMap`. Maintaining the
+    // registry anyway cost a lock plus an ahash lookup on every new-key insert AND — since this
+    // file has no eviction of any kind — a permanent `ShapeNode` plus an `Arc::clone` of the key
+    // for every distinct construction path, for the life of the program, on a 136 KB heap.
+    // Opt out via the sentinel the file already defines for exactly this case: `DICT_SHAPE` never
+    // matches an inline cache, so any future reader degrades to the slow path rather than trusting
+    // a slot index that was never recorded.
+    #[cfg(feature = "portable")]
+    {
+        let _ = (from, key);
+        DICT_SHAPE
+    }
+    #[cfg(not(feature = "portable"))]
+    {
+        transition_tracked(from, key)
+    }
+}
+
+#[cfg(not(feature = "portable"))]
+fn transition_tracked(from: ShapeId, key: &Arc<str>) -> ShapeId {
     if from == DICT_SHAPE {
         return DICT_SHAPE;
     }