@tishlang/tish 1.9.2 → 1.12.0

package/crates/js_to_tish/src/transform/expr.rs

@@ -539,9 +539,10 @@ pub fn convert_params(
         let fp = p;
         {
             let (name, name_span) = match &fp.pattern {
-                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                }
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                    b.name.as_str(),
+                    crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                ),
                 _ => {
                     return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                         what: "destructuring in params".into(),
@@ -565,9 +566,10 @@ pub fn convert_params(
     if rest_param.is_none() {
         if let Some(rest) = &params.rest {
             let (rest_name, rest_name_span) = match &rest.rest.argument {
-                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                    (b.name.as_str(), crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                }
+                oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                    b.name.as_str(),
+                    crate::span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                ),
                 _ => {
                     return Err(ConvertError::new(ConvertErrorKind::Unsupported {
                         what: "rest param with non-identifier".into(),

package/crates/js_to_tish/src/transform/stmt.rs

@@ -247,9 +247,10 @@ fn convert_for_of_statement(
             if v.declarations.len() == 1 {
                 let d = &v.declarations[0];
                 match &d.id {
-                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => {
-                        (b.name.as_str(), span_util::oxc_span_to_tish(ctx.1, b.as_ref()))
-                    }
+                    oxc::ast::ast::BindingPattern::BindingIdentifier(b) => (
+                        b.name.as_str(),
+                        span_util::oxc_span_to_tish(ctx.1, b.as_ref()),
+                    ),
                     _ => {
                         return Err(ConvertError::new(ConvertErrorKind::Incompatible {
                             what: "for-of with destructuring".into(),
@@ -368,16 +369,14 @@ fn convert_function_decl(
     span: Span,
 ) -> Result<Statement, ConvertError> {
     let async_ = f.r#async;
-    let name: Arc<str> = f
-        .id
-        .as_ref()
-        .map(|id| Arc::from(id.name.as_str()))
-        .unwrap_or_else(|| Arc::from(""));
-    let name_span = f
-        .id
-        .as_ref()
-        .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
-        .unwrap_or_else(span_util::stub_span);
+    let name: Arc<str> =
+        f.id.as_ref()
+            .map(|id| Arc::from(id.name.as_str()))
+            .unwrap_or_else(|| Arc::from(""));
+    let name_span =
+        f.id.as_ref()
+            .map(|id| span_util::oxc_span_to_tish(ctx.1, id))
+            .unwrap_or_else(span_util::stub_span);
     let (params, rest_param) = expr::convert_params(&f.params, ctx)?;
     let body = match &f.body {
         Some(fb) => {

package/crates/tish/Cargo.toml

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

package/crates/tish/src/cargo_native_registry.rs

@@ -19,7 +19,10 @@ pub(crate) fn register_bytecode_native_modules(vm: &mut tishlang_vm::Vm) {
         Arc::from("query_prepared"),
         Value::native(tishlang_pg::query_prepared),
     );
-    om.insert(Arc::from("query_all"), Value::native(tishlang_pg::query_all));
+    om.insert(
+        Arc::from("query_all"),
+        Value::native(tishlang_pg::query_all),
+    );
     om.insert(Arc::from("migrate"), Value::native(tishlang_pg::migrate));
     om.insert(Arc::from("close"), Value::native(tishlang_pg::close));
     vm.register_native_module("cargo:tish_pg", om);

package/crates/tish/src/cli_help.rs

@@ -405,6 +405,8 @@ pub fn build_after_help() -> String {
           WebAssembly (.tish project; .js source supported on some paths)
   {t}wasi{r}
           WASI WebAssembly
+  {t}bytecode{r}
+          Raw serialized bytecode chunk (no VM binary/JS/HTML); for hosts that already ship the runtime
 
 {oh}Native backends{r} (--native-backend, only with --target native, default: rust):
   {t}rust{r}
@@ -506,7 +508,7 @@ pub(crate) struct BuildArgs {
         help_heading = "Options"
     )]
     pub output: String,
-    /// `native`, `js`, `wasm`, or `wasi` (see long help below).
+    /// `native`, `js`, `wasm`, `wasi`, or `bytecode` (see long help below).
     #[arg(
         long,
         default_value = "native",
@@ -530,6 +532,12 @@ pub(crate) struct BuildArgs {
         help_heading = "Options"
     )]
     pub features: Vec<String>,
+    /// Cross-compile to an Apple iOS triple (e.g. `aarch64-apple-ios-sim`). Implies `--crate-type staticlib`.
+    #[arg(long, value_name = "TRIPLE", help_heading = "Options")]
+    pub ios_triple: Option<String>,
+    /// Output artifact for `--target native` (default: `bin`; use `staticlib` for embedded iOS).
+    #[arg(long, value_name = "TYPE", default_value = "bin", help_heading = "Options")]
+    pub crate_type: String,
     #[arg(long, help_heading = "Options")]
     pub no_optimize: bool,
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).

package/crates/tish/src/main.rs

@@ -4,13 +4,11 @@ mod cargo_native_registry;
 mod cli_help;
 mod repl_completion;
 
-use std::cell::RefCell;
-use tishlang_core::VmRef;
 use std::collections::HashSet;
 use std::fs;
 use std::io::{self, IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
-use std::rc::Rc;
+use tishlang_core::VmRef;
 
 use clap::FromArgMatches;
 use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
@@ -113,6 +111,8 @@ fn main() {
             &a.features,
             a.no_optimize || no_opt_env,
             a.source_map,
+            a.ios_triple.as_deref(),
+            &a.crate_type,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => {
@@ -516,13 +516,14 @@ fn compile_to_js(
         } else {
             program
         };
-        let js = tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?;
+        let js =
+            tishlang_compile_js::compile_with_jsx(&p, optimize).map_err(|e| format!("{}", e))?;
         (js, None)
     } else if input_path.extension().map(|e| e == "js") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
-        let js =
-            tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?;
+        let js = tishlang_compile_js::compile_with_jsx(&program, optimize)
+            .map_err(|e| format!("{}", e))?;
         (js, None)
     } else if source_map {
         let bundle = tishlang_compile_js::compile_project_with_jsx_and_source_map(
@@ -545,7 +546,8 @@ fn compile_to_js(
     let mut js_out = js;
     if let Some(map) = &map_json {
         let map_path = out_path.with_extension("js.map");
-        fs::write(&map_path, map).map_err(|e| format!("Cannot write {}: {}", map_path.display(), e))?;
+        fs::write(&map_path, map)
+            .map_err(|e| format!("Cannot write {}: {}", map_path.display(), e))?;
         let map_url = map_path
             .file_name()
             .and_then(|s| s.to_str())
@@ -553,7 +555,8 @@ fn compile_to_js(
         js_out.push_str(&format!("\n//# sourceMappingURL={map_url}\n"));
         println!("Built: {}", map_path.display());
     }
-    fs::write(&out_path, js_out).map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
+    fs::write(&out_path, js_out)
+        .map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
     println!("Built: {}", out_path.display());
     Ok(())
 }
@@ -567,6 +570,8 @@ fn build_file(
     cli_features: &[String],
     no_optimize: bool,
     source_map: bool,
+    ios_triple: Option<&str>,
+    crate_type: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -611,18 +616,37 @@ fn build_file(
                 Some(p)
             }
         });
+        let features = native_build_features_from_cli(cli_features);
         return tishlang_wasm::compile_to_wasi(
             &input_path,
             project_root,
             Path::new(output_path),
             optimize,
+            &features,
+        )
+        .map_err(|e| e.to_string());
+    }
+
+    if target == "bytecode" {
+        let project_root = input_path.parent().and_then(|p| {
+            if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+                p.parent()
+            } else {
+                Some(p)
+            }
+        });
+        return tishlang_wasm::compile_to_bytecode(
+            &input_path,
+            project_root,
+            Path::new(output_path),
+            optimize,
         )
         .map_err(|e| e.to_string());
     }
 
     if target != "native" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'js', 'wasm', or 'wasi'.",
+            "Unknown target: {}. Use 'native', 'js', 'wasm', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -636,9 +660,31 @@ fn build_file(
     });
     let features: Vec<String> = native_build_features_from_cli(cli_features);
 
+    let build_config = if let Some(triple) = ios_triple {
+        tishlang_native::NativeBuildConfig::ios_staticlib(triple)
+    } else if crate_type == "staticlib" {
+        tishlang_native::NativeBuildConfig {
+            artifact: tishlang_native::NativeArtifact::StaticLib,
+            cargo_target: None,
+            emit_mode: tishlang_compile::NativeEmitMode::EmbeddedLib,
+        }
+    } else if crate_type != "bin" {
+        return Err(format!(
+            "Unknown --crate-type: {}. Use 'bin' or 'staticlib'.",
+            crate_type
+        ));
+    } else {
+        tishlang_native::NativeBuildConfig::desktop()
+    };
+
     if is_js {
         let source = fs::read_to_string(&input_path).map_err(|e| format!("{}", e))?;
         let program = tishlang_js_to_tish::convert(&source).map_err(|e| format!("{}", e))?;
+        if build_config.artifact != tishlang_native::NativeArtifact::Bin {
+            return Err(
+                "--crate-type staticlib / --ios-triple require a .tish entry file.".to_string(),
+            );
+        }
         tishlang_native::compile_program_to_native(
             &program,
             project_root,
@@ -649,13 +695,14 @@ fn build_file(
         )
         .map_err(|e| e.to_string())?;
     } else {
-        tishlang_native::compile_to_native(
+        tishlang_native::compile_to_native_with_config(
             &input_path,
             project_root,
             Path::new(output_path),
             &features,
             native_backend,
             optimize,
+            &build_config,
         )
         .map_err(|e| e.to_string())?;
     }
@@ -664,7 +711,15 @@ fn build_file(
         .file_stem()
         .and_then(|s| s.to_str())
         .unwrap_or("tish_out");
-    let built_path = if output_path.ends_with('/') || Path::new(output_path).is_dir() {
+    let built_path = if build_config.artifact == tishlang_native::NativeArtifact::StaticLib {
+        if output_path.ends_with('/') || Path::new(output_path).is_dir() {
+            Path::new(output_path).join(format!("lib{out_name}.a"))
+        } else if output_path.ends_with(".a") {
+            Path::new(output_path).to_path_buf()
+        } else {
+            Path::new(output_path).with_extension("a")
+        }
+    } else if output_path.ends_with('/') || Path::new(output_path).is_dir() {
         Path::new(output_path).join(out_name)
     } else {
         Path::new(output_path).to_path_buf()

package/crates/tish/tests/integration_test.rs

@@ -5,6 +5,7 @@
 //! - Generate/update expected files: `REGENERATE_EXPECTED=1 cargo test -p tishlangtest_mvp_programs_interpreter`
 //!   then commit the new/updated `tests/core/*.tish.expected` files.
 //! - Compiled outputs are cached under `target/integration_compile_cache/` per backend.
+//!   MVP native tests use `native_many/<hash>/` plus one batched nested Cargo build.
 
 use std::collections::hash_map::DefaultHasher;
 use std::ffi::OsString;
@@ -14,6 +15,7 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use rayon::prelude::*;
+use tishlang_native::compile_many_to_native;
 
 fn workspace_root() -> PathBuf {
     PathBuf::from(env!("CARGO_MANIFEST_DIR"))
@@ -50,6 +52,72 @@ fn integration_compile_cache_dir() -> PathBuf {
     target_dir().join("integration_compile_cache")
 }
 
+/// Match `tish build` with no `--feature`: link every capability compiled into this `tish` binary.
+fn native_build_features_for_integration_test() -> Vec<String> {
+    let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities()
+        .into_iter()
+        .collect();
+    v.sort();
+    v
+}
+
+fn combined_mvp_native_inputs_hash(paths: &[PathBuf]) -> u64 {
+    let mut h = DefaultHasher::new();
+    let feats = native_build_features_for_integration_test();
+    feats.len().hash(&mut h);
+    for f in &feats {
+        f.hash(&mut h);
+    }
+    paths.len().hash(&mut h);
+    for p in paths {
+        p.file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .hash(&mut h);
+        file_content_hash(p).hash(&mut h);
+    }
+    // Native batch cache must invalidate when the emitter or `value_call` changes — not only
+    // when `.tish` sources change; otherwise CI/rust-cache can keep stale nested binaries.
+    let codegen_rs = workspace_root().join("crates/tish_compile/src/codegen.rs");
+    if codegen_rs.is_file() {
+        file_content_hash(&codegen_rs).hash(&mut h);
+    }
+    let value_rs = workspace_root().join("crates/tish_core/src/value.rs");
+    if value_rs.is_file() {
+        file_content_hash(&value_rs).hash(&mut h);
+    }
+    h.finish()
+}
+
+fn mvp_native_batch_cache_dir(combined: u64) -> PathBuf {
+    integration_compile_cache_dir()
+        .join("native_many")
+        .join(format!("{:016x}", combined))
+}
+
+/// Restores the previous process env when dropped (for `TISH_FAST_NATIVE_BUILD` in batch tests).
+struct EnvVarGuard {
+    key: &'static str,
+    previous: Option<std::ffi::OsString>,
+}
+
+impl EnvVarGuard {
+    fn set(key: &'static str, value: &str) -> Self {
+        let previous = std::env::var_os(key);
+        std::env::set_var(key, value);
+        Self { key, previous }
+    }
+}
+
+impl Drop for EnvVarGuard {
+    fn drop(&mut self) {
+        match &self.previous {
+            None => std::env::remove_var(self.key),
+            Some(v) => std::env::set_var(self.key, v),
+        }
+    }
+}
+
 fn file_content_hash(path: &Path) -> u64 {
     let mut f = std::fs::File::open(path).expect("open file for hash");
     let mut content = Vec::new();
@@ -583,6 +651,7 @@ const MVP_TEST_FILES: &[&str] = &[
     "break_continue.tish",
     "length.tish",
     "objects.tish",
+    "symbol.tish",
     "conditional.tish",
     "switch.tish",
     "do_while.tish",
@@ -714,6 +783,7 @@ fn test_mvp_programs_interp_vm_stdout_parity() {
 /// Compile each .tish file to native, run, and compare stdout to static expected (parallelized).
 #[test]
 fn test_mvp_programs_native() {
+    let _fast_native = EnvVarGuard::set("TISH_FAST_NATIVE_BUILD", "1");
     let core_dir = core_dir();
     let bin = tish_bin();
     assert!(
@@ -721,18 +791,86 @@ fn test_mvp_programs_native() {
         "tish binary not found at {}. Run `cargo build -p tishlang` first.",
         bin.display()
     );
-    let errors: Vec<String> = MVP_TEST_FILES
-        .par_iter()
+
+    let mut paths: Vec<PathBuf> = MVP_TEST_FILES
+        .iter()
         .filter_map(|name| {
-            let path = core_dir.join(name);
-            if !path.exists() {
-                return None;
+            let p = core_dir.join(name);
+            if p.exists() {
+                Some(p)
+            } else {
+                None
             }
-            let expected = match get_expected(&path) {
+        })
+        .collect();
+    paths.sort();
+
+    if paths.is_empty() {
+        return;
+    }
+
+    let combined = combined_mvp_native_inputs_hash(&paths);
+    let cache_dir = mvp_native_batch_cache_dir(combined);
+    let _ = std::fs::create_dir_all(&cache_dir);
+
+    let ext = if cfg!(target_os = "windows") {
+        ".exe"
+    } else {
+        ""
+    };
+
+    let entries_owned: Vec<(PathBuf, PathBuf)> = paths
+        .iter()
+        .map(|p| {
+            let stem = p.file_stem().unwrap().to_string_lossy();
+            let cached = cache_dir.join(format!("{}{}", stem, ext));
+            (p.clone(), cached)
+        })
+        .collect();
+
+    let need_build = entries_owned.iter().any(|(_, o)| !o.exists());
+    if need_build {
+        let refs: Vec<(&Path, &Path)> = entries_owned
+            .iter()
+            .map(|(a, b)| (a.as_path(), b.as_path()))
+            .collect();
+        let feats = native_build_features_for_integration_test();
+        compile_many_to_native(&refs, Some(workspace_root().as_path()), &feats, true)
+            .unwrap_or_else(|e| panic!("compile_many_to_native: {}", e.message));
+    }
+
+    // Run each binary sequentially. Parallel `fs::copy` + `exec` caused Linux ETXTBSY (errno 26)
+    // in CI when several threads replaced/ran temp executables under load.
+    let errors: Vec<String> = entries_owned
+        .iter()
+        .enumerate()
+        .filter_map(|(run_index, (path, cached_bin))| {
+            let expected = match get_expected(path) {
                 Some(e) => e,
                 None => return Some(format!("missing expected: {}", path.display())),
             };
-            let out_bin = compile_cached(&bin, &path, "native");
+            if !cached_bin.exists() {
+                return Some(format!("missing cached binary: {}", cached_bin.display()));
+            }
+            let stem = path.file_stem().unwrap().to_string_lossy();
+            let ext_bin = cached_bin
+                .extension()
+                .map(|e| e.to_string_lossy().to_string())
+                .unwrap_or_default();
+            let temp_dest = std::env::temp_dir().join(format!(
+                "tish_mvp_native_{}_{:x}_{}_{}",
+                stem,
+                file_content_hash(path),
+                std::process::id(),
+                run_index
+            ));
+            let temp_dest = if ext_bin.is_empty() {
+                temp_dest
+            } else {
+                temp_dest.with_extension(&ext_bin)
+            };
+            std::fs::copy(cached_bin, &temp_dest).expect("copy cached native bin to temp");
+            let out_bin = temp_dest;
             let out = match Command::new(&out_bin)
                 .current_dir(workspace_root())
                 .output()

package/crates/tish_ast/src/ast.rs

@@ -129,15 +129,9 @@ pub enum ImportSpecifier {
         alias_span: Option<Span>,
     },
     /// Namespace: * as M
-    Namespace {
-        name: Arc<str>,
-        name_span: Span,
-    },
+    Namespace { name: Arc<str>, name_span: Span },
     /// Default: import X from "..."
-    Default {
-        name: Arc<str>,
-        name_span: Span,
-    },
+    Default { name: Arc<str>, name_span: Span },
 }
 
 /// Export declaration: named (const/let/fn) or default
@@ -616,7 +610,7 @@ impl Statement {
             | Statement::DoWhile { span, .. }
             | Statement::Throw { span, .. }
             | Statement::Try { span, .. }
-            |             Statement::Import { span, .. }
+            | Statement::Import { span, .. }
             | Statement::Export { span, .. }
             | Statement::TypeAlias { span, .. }
             | Statement::DeclareVar { span, .. }

package/crates/tish_build_utils/src/lib.rs

@@ -6,6 +6,18 @@
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::Mutex;
+
+/// Serialize nested `cargo build` calls that share the workspace `target/` dir (tests + `tish build`).
+static NESTED_CARGO_MUTEX: Mutex<()> = Mutex::new(());
+
+fn mold_available() -> bool {
+    Command::new("mold")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false)
+}
 
 /// True if `root` looks like the Tish language repo (has `crates/tish_runtime`).
 ///
@@ -161,7 +173,11 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
             let candidate = dir.join("tish");
             if is_tish_workspace_root(&candidate) {
                 return candidate.canonicalize().map_err(|e| {
-                    format!("Cannot canonicalize Tish workspace {}: {}", candidate.display(), e)
+                    format!(
+                        "Cannot canonicalize Tish workspace {}: {}",
+                        candidate.display(),
+                        e
+                    )
                 });
             }
             if !dir.pop() {
@@ -322,6 +338,11 @@ pub fn find_crate_path(crate_name: &str) -> Result<PathBuf, String> {
     Ok(crate_path)
 }
 
+/// Sanitize a user-chosen output stem for Cargo `[lib]` / `[[bin]]` target names.
+pub fn cargo_target_name(stem: &str) -> String {
+    stem.replace('-', "_")
+}
+
 /// Create a temp build directory with src subdir.
 pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String> {
     let build_dir =
@@ -364,26 +385,36 @@ fn protoc_for_nested_cargo() -> Option<PathBuf> {
 }
 
 /// Run cargo build in the given directory.
-/// If target_dir is Some, use that for --target-dir (e.g. workspace target for caching).
-pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<(), String> {
+/// If `cross_target` is Some, passes `--target` and skips `-C target-cpu=native`.
+pub fn run_cargo_build(
+    build_dir: &Path,
+    target_dir: Option<&Path>,
+    cross_target: Option<&str>,
+) -> Result<(), String> {
+    let _nested_guard = NESTED_CARGO_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+
     let target_dir = target_dir
         .map(|p| p.to_path_buf())
         .unwrap_or_else(|| build_dir.join("target"));
-    // Default to target-cpu=native so the emitted binary uses every SIMD / ISA
-    // extension the build host supports. Callers can override by pre-setting
-    // RUSTFLAGS in the environment.
-    let existing_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
-    let merged_rustflags = if existing_rustflags.is_empty() {
-        "-C target-cpu=native".to_string()
-    } else if existing_rustflags.contains("target-cpu") {
-        existing_rustflags
-    } else {
-        format!("{} -C target-cpu=native", existing_rustflags)
-    };
-    // Nested `cargo build` (e.g. `tish build --native-backend rust`) inherits the parent
-    // environment. CI often sets `RUSTC_WRAPPER=sccache`; wrapping this inner compile too can
-    // cause flaky or failed builds (LTO / temp-crate paths). Use plain rustc here; the main
-    // workspace build still benefits from the wrapper.
+    let fast_native = std::env::var("TISH_FAST_NATIVE_BUILD").as_deref() == Ok("1");
+
+    let mut merged_rustflags = std::env::var("RUSTFLAGS").unwrap_or_default();
+    if cross_target.is_some() {
+        // Cross-compiling (e.g. iOS): do not use host target-cpu.
+    } else if fast_native {
+        if cfg!(target_os = "linux")
+            && mold_available()
+            && !merged_rustflags.contains("fuse-ld=mold")
+        {
+            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);
+    }
+
     let mut cmd = Command::new("cargo");
     cmd.args(["build", "--release", "--target-dir"])
         .arg(&target_dir)
@@ -394,6 +425,14 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
         .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
         .env("RUSTFLAGS", &merged_rustflags);
+    if let Some(triple) = cross_target {
+        cmd.arg("--target").arg(triple);
+    }
+    if fast_native {
+        cmd.env("CARGO_INCREMENTAL", "1");
+    } else {
+        cmd.env_remove("CARGO_INCREMENTAL");
+    }
     if let Some(protoc) = protoc_for_nested_cargo() {
         cmd.env("PROTOC", protoc);
     }
@@ -416,17 +455,29 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
 mod protoc_tests {
     use super::*;
 
+    #[test]
+    fn cargo_target_name_replaces_hyphens() {
+        assert_eq!(cargo_target_name("hello-ios"), "hello_ios");
+        assert_eq!(cargo_target_name("tish_out"), "tish_out");
+    }
+
     #[test]
     fn protoc_for_nested_cargo_without_env_uses_vendored_or_path() {
         let _lock = std::sync::Mutex::new(());
         let _guard = _lock.lock().unwrap();
         std::env::remove_var("PROTOC");
         let p = protoc_for_nested_cargo().expect("expected vendored or PATH protoc");
-        assert!(
-            p.exists(),
-            "resolved protoc should exist: {}",
-            p.display()
-        );
+        assert!(p.exists(), "resolved protoc should exist: {}", p.display());
+    }
+}
+
+/// Find the built static library in target/release (or target/$TRIPLE/release).
+pub fn find_release_staticlib(binary_dir: &Path, lib_name: &str) -> Result<PathBuf, String> {
+    let path = binary_dir.join(format!("lib{lib_name}.a"));
+    if path.exists() {
+        Ok(path)
+    } else {
+        Err(format!("Static library not found at {}", path.display()))
     }
 }