@tishlang/tish 1.7.0 → 1.9.0

package/crates/tish/src/main.rs

@@ -1,9 +1,11 @@
 //! Tish CLI - run, REPL, build to native or other targets.
 
+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};
@@ -15,13 +17,13 @@ use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 
 use cli_help::{Cli, Commands};
 
-/// Normalize `--feature` / `--feature http,fs` / `--feature full` for VM runs and native builds.
+/// Normalize `--feature` / `--feature http,timers,fs` / `--feature full` for VM runs and native builds.
 fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
     let mut out = HashSet::new();
     for s in features {
         for part in s.split(',').map(str::trim).filter(|p| !p.is_empty()) {
             if part == "full" {
-                for name in ["http", "fs", "process", "regex", "ws"] {
+                for name in ["http", "timers", "fs", "process", "regex", "ws"] {
                     out.insert(name.to_string());
                 }
             } else {
@@ -110,6 +112,7 @@ fn main() {
             &a.native_backend,
             &a.features,
             a.no_optimize || no_opt_env,
+            a.source_map,
         ),
         Some(Commands::DumpAst { file }) => dump_ast(&file),
         None => {
@@ -160,7 +163,7 @@ fn run_stdin_source(
     let cwd = std::env::current_dir().map_err(|e| e.to_string())?;
     let modules = tishlang_compile::resolve_project_from_stdin(source, &cwd)?;
     tishlang_compile::detect_cycles(&modules)?;
-    let prog = tishlang_compile::merge_modules(modules)?;
+    let prog = tishlang_compile::merge_modules(modules)?.program;
     let program = if no_optimize {
         prog
     } else {
@@ -202,7 +205,7 @@ fn run_file(
         } else {
             let modules = tishlang_compile::resolve_project(&path, project_root)?;
             tishlang_compile::detect_cycles(&modules)?;
-            let prog = tishlang_compile::merge_modules(modules)?;
+            let prog = tishlang_compile::merge_modules(modules)?.program;
             if no_optimize {
                 prog
             } else {
@@ -223,6 +226,10 @@ fn run_program(
     if backend == "interp" {
         let mut eval = tishlang_eval::Evaluator::new();
         let value = eval.eval_program(program)?;
+        #[cfg(feature = "timers")]
+        {
+            let _ = eval.run_timer_phase();
+        }
         if !matches!(value, tishlang_eval::Value::Null) {
             println!(
                 "{}",
@@ -241,13 +248,9 @@ fn run_program(
         tishlang_bytecode::compile(program).map_err(|e| e.to_string())?
     };
     let caps = vm_capabilities_for_cli_run(features);
-    let value = tishlang_vm::run_with_options(
-        &chunk,
-        tishlang_vm::VmRunOptions {
-            repl_mode: false,
-            capabilities: caps,
-        },
-    )?;
+    let mut vm = tishlang_vm::Vm::with_capabilities(caps);
+    cargo_native_registry::register_bytecode_native_modules(&mut vm);
+    let value = vm.run_with_options(&chunk, false)?;
     if !matches!(value, tishlang_core::Value::Null) {
         println!(
             "{}",
@@ -294,6 +297,10 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
                 Ok(program) => {
                     match eval.eval_program(&program) {
                         Ok(v) => {
+                            #[cfg(feature = "timers")]
+                            {
+                                let _ = eval.run_timer_phase();
+                            }
                             if !matches!(v, tishlang_eval::Value::Null) {
                                 println!(
                                     "{}",
@@ -325,11 +332,11 @@ fn run_repl(backend: &str, no_optimize: bool, features: &[String]) -> Result<(),
     if !std::io::stdin().is_terminal() {
         eprintln!("Note: Tab completion and grey preview require an interactive terminal (TTY).");
     }
-    let vm = Rc::new(RefCell::new(tishlang_vm::Vm::with_capabilities(
-        vm_capabilities_for_cli_run(features),
-    )));
+    let mut vm0 = tishlang_vm::Vm::with_capabilities(vm_capabilities_for_cli_run(features));
+    cargo_native_registry::register_bytecode_native_modules(&mut vm0);
+    let vm = VmRef::new(vm0);
     let completer = repl_completion::ReplCompleter {
-        vm: Rc::clone(&vm),
+        vm: vm.clone(),
         no_optimize,
     };
     let config = Config::builder()
@@ -455,7 +462,27 @@ fn tish_history_path() -> Option<PathBuf> {
     home.map(|h| PathBuf::from(h).join(".tish_history"))
 }
 
-fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result<(), String> {
+fn compile_to_js(
+    input_path: &Path,
+    output_path: &str,
+    optimize: bool,
+    source_map: bool,
+) -> Result<(), String> {
+    if source_map && optimize {
+        return Err(
+            "tish build --target js --source-map requires --no-optimize (mappings follow unmerged statement order)."
+                .into(),
+        );
+    }
+    if source_map
+        && (input_path.extension().map(|e| e == "jsx") == Some(true)
+            || input_path.extension().map(|e| e == "js") == Some(true))
+    {
+        return Err(
+            "tish build --target js --source-map is only supported for .tish project builds (not single-file .jsx / .js inputs)."
+                .into(),
+        );
+    }
     let project_root = input_path.parent().and_then(|p| {
         if p.file_name().and_then(|n| n.to_str()) == Some("src") {
             p.parent()
@@ -463,7 +490,20 @@ fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result
             Some(p)
         }
     });
-    let js = if input_path.extension().map(|e| e == "jsx") == Some(true) {
+    let out_path = Path::new(output_path);
+    let out_path = if out_path.extension().is_none()
+        || out_path.extension() == Some(std::ffi::OsStr::new(""))
+    {
+        out_path.with_extension("js")
+    } else {
+        out_path.to_path_buf()
+    };
+    let out_js_name = out_path
+        .file_name()
+        .and_then(|s| s.to_str())
+        .unwrap_or("out.js");
+
+    let (js, map_json) = if input_path.extension().map(|e| e == "jsx") == Some(true) {
         let source = fs::read_to_string(input_path).map_err(|e| format!("{}", e))?;
         let wrapped = format!(
             "export fn __TishJsxRoot() {{\n  return (\n{}\n  )\n}}",
@@ -476,30 +516,44 @@ fn compile_to_js(input_path: &Path, output_path: &str, optimize: bool) -> Result
         } else {
             program
         };
-        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))?;
-        tishlang_compile_js::compile_with_jsx(&program, optimize).map_err(|e| format!("{}", e))?
-    } else {
-        tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
-            .map_err(|e| format!("{}", e))?
-    };
-
-    let out_path = Path::new(output_path);
-    let out_path = if out_path.extension().is_none()
-        || out_path.extension() == Some(std::ffi::OsStr::new(""))
-    {
-        out_path.with_extension("js")
+        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(
+            input_path,
+            project_root,
+            out_js_name,
+        )
+        .map_err(|e| format!("{}", e))?;
+        (bundle.js, bundle.source_map_json)
     } else {
-        out_path.to_path_buf()
+        let js = tishlang_compile_js::compile_project_with_jsx(input_path, project_root, optimize)
+            .map_err(|e| format!("{}", e))?;
+        (js, None)
     };
 
     if let Some(parent) = out_path.parent() {
         fs::create_dir_all(parent)
             .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
     }
-    fs::write(&out_path, js).map_err(|e| format!("Cannot write {}: {}", out_path.display(), e))?;
+    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))?;
+        let map_url = map_path
+            .file_name()
+            .and_then(|s| s.to_str())
+            .unwrap_or("out.js.map");
+        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))?;
     println!("Built: {}", out_path.display());
     Ok(())
 }
@@ -512,6 +566,7 @@ fn build_file(
     native_backend: &str,
     cli_features: &[String],
     no_optimize: bool,
+    source_map: bool,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -521,7 +576,7 @@ fn build_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize);
+        return compile_to_js(&input_path, output_path, optimize, source_map);
     }
 
     if target == "wasm" && is_js {

package/crates/tish/src/repl_completion.rs

@@ -2,8 +2,8 @@
 //! Grey preview hint below the line (like Node) and Tab for full list.
 
 use std::borrow::Cow;
-use std::cell::RefCell;
-use std::rc::Rc;
+
+use tishlang_core::VmRef;
 
 use rustyline::completion::{Completer, Pair};
 use rustyline::highlight::Highlighter;
@@ -29,7 +29,7 @@ const ANSI_RESET: &str = "\x1b[0m";
 
 /// Tab completer that evaluates the expression before the last `.` and suggests property/method names.
 pub struct ReplCompleter {
-    pub vm: Rc<RefCell<Vm>>,
+    pub vm: VmRef<Vm>,
     pub no_optimize: bool,
 }
 

package/crates/tish/tests/cargo_example_compile.rs

@@ -39,7 +39,7 @@ fn resolve_and_merge_cargo_example_fixture() {
         panic!("expected import, got {:?}", first);
     };
     assert_eq!(from.as_ref(), "cargo:demo_shim");
-    merge_modules(modules).unwrap();
+    let _ = merge_modules(modules).unwrap();
 }
 
 #[test]

package/crates/tish/tests/integration_test.rs

@@ -66,12 +66,20 @@ fn file_content_hash(path: &Path) -> u64 {
 ///
 /// Cache is keyed by backend (native, cranelift, js, wasi) so e.g. cranelift and wasi
 /// compiles of the same file do not overwrite each other: .../cranelift/<stem>_<hash> vs .../wasi/<stem>_<hash>.wasm.
+///
+/// The artifact **basename** must be unique per `(stem, hash, backend)`: nested `tish build`
+/// uses it as the Cargo binary name under the workspace `target/release/`. If native and
+/// cranelift both used `strict_equality_<hash>`, parallel `cargo nextest` could run those
+/// tests concurrently and corrupt the same `target/release/...` output (Linux: ETXTBSY when
+/// executing a binary still being written).
 fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
     let stem = path.file_stem().unwrap().to_string_lossy();
     let hash = file_content_hash(path);
     let hash8 = &format!("{:016x}", hash)[..8];
     let cache_base = integration_compile_cache_dir().join(backend);
     let _ = std::fs::create_dir_all(&cache_base);
+    // Include `backend` in the leaf name so nested cargo bin names never collide across backends.
+    let leaf = format!("{}__{}__{}", stem, backend, hash8);
 
     let (artifact_path, compile_args): (PathBuf, Vec<OsString>) = match backend {
         "native" => {
@@ -80,7 +88,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             } else {
                 ""
             };
-            let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -95,7 +103,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             } else {
                 ""
             };
-            let cached = cache_base.join(format!("{}_{}{}", stem, hash8, ext));
+            let cached = cache_base.join(format!("{}{}", leaf, ext));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -107,7 +115,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             (cached, args)
         }
         "js" => {
-            let cached = cache_base.join(format!("{}_{}.js", stem, hash8));
+            let cached = cache_base.join(format!("{}.js", leaf));
             let args = vec![
                 OsString::from("build"),
                 OsString::from(path),
@@ -119,7 +127,7 @@ fn compile_cached(bin: &Path, path: &Path, backend: &str) -> PathBuf {
             (cached, args)
         }
         "wasi" => {
-            let out_base = cache_base.join(format!("{}_{}", stem, hash8));
+            let out_base = cache_base.join(&leaf);
             let artifact = out_base.with_extension("wasm");
             let args = vec![
                 OsString::from("build"),
@@ -397,7 +405,7 @@ fn test_async_await_run() {
     }
 }
 
-/// Run Promise and setTimeout module tests (require http feature).
+/// Run Promise and setTimeout module tests (`promise` needs `http`; `settimeout` needs `timers`, which `http` enables).
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]
@@ -455,7 +463,9 @@ fn test_vm_date_now() {
     // Library path
     let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
     tishlang_compile::detect_cycles(&modules).expect("cycles");
-    let program = tishlang_compile::merge_modules(modules).expect("merge");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
     let chunk = tishlang_bytecode::compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
     assert!(
@@ -499,7 +509,9 @@ fn test_vm_index_assign_via_resolve() {
         .join("array_sort_minimal.tish");
     let modules = tishlang_compile::resolve_project(&path, path.parent()).expect("resolve");
     tishlang_compile::detect_cycles(&modules).expect("cycles");
-    let program = tishlang_compile::merge_modules(modules).expect("merge");
+    let program = tishlang_compile::merge_modules(modules)
+        .expect("merge")
+        .program;
     let chunk = tishlang_bytecode::compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);
     assert!(

package/crates/tish/tests/shortcircuit.rs

@@ -53,7 +53,7 @@ fn test_and_shortcircuit_via_resolve_project() {
     let path = path.canonicalize().expect("path");
     let project_root = path.parent().unwrap();
     let modules = resolve_project(&path, Some(project_root)).expect("resolve");
-    let program = merge_modules(modules).expect("merge");
+    let program = merge_modules(modules).expect("merge").program;
     let program = tishlang_opt::optimize(&program); // Mirror CLI
     let chunk = compile(&program).expect("compile");
     let result = tishlang_vm::run(&chunk);

package/crates/tish_ast/src/ast.rs

@@ -30,6 +30,7 @@ pub enum TypeAnnotation {
 #[derive(Debug, Clone, PartialEq)]
 pub struct TypedParam {
     pub name: Arc<str>,
+    pub name_span: Span,
     pub type_ann: Option<TypeAnnotation>,
     pub default: Option<Expr>,
 }
@@ -64,11 +65,11 @@ impl FunParam {
                 for el in elements {
                     if let Some(el) = el {
                         match el {
-                            DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                            DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                             DestructElement::Pattern(p) => {
                                 Self::collect_pattern_binding_names(p, out);
                             }
-                            DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                            DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                         }
                     }
                 }
@@ -76,11 +77,11 @@ impl FunParam {
             DestructPattern::Object(props) => {
                 for prop in props {
                     match &prop.value {
-                        DestructElement::Ident(n) => out.push(Arc::clone(n)),
+                        DestructElement::Ident(n, _) => out.push(Arc::clone(n)),
                         DestructElement::Pattern(p) => {
                             Self::collect_pattern_binding_names(p, out);
                         }
-                        DestructElement::Rest(n) => out.push(Arc::clone(n)),
+                        DestructElement::Rest(n, _) => out.push(Arc::clone(n)),
                     }
                 }
             }
@@ -101,11 +102,11 @@ pub enum DestructPattern {
 #[derive(Debug, Clone, PartialEq)]
 pub enum DestructElement {
     /// Simple binding: a
-    Ident(Arc<str>),
+    Ident(Arc<str>, Span),
     /// Nested pattern: [a, b] or { x, y }
     Pattern(Box<DestructPattern>),
     /// Rest element: ...rest
-    Rest(Arc<str>),
+    Rest(Arc<str>, Span),
 }
 
 /// Property in object destructuring pattern
@@ -123,12 +124,20 @@ pub enum ImportSpecifier {
     /// Named: { foo } or { foo as bar }
     Named {
         name: Arc<str>,
+        name_span: Span,
         alias: Option<Arc<str>>,
+        alias_span: Option<Span>,
     },
     /// Namespace: * as M
-    Namespace(Arc<str>),
+    Namespace {
+        name: Arc<str>,
+        name_span: Span,
+    },
     /// Default: import X from "..."
-    Default(Arc<str>),
+    Default {
+        name: Arc<str>,
+        name_span: Span,
+    },
 }
 
 /// Export declaration: named (const/let/fn) or default
@@ -153,6 +162,7 @@ pub enum Statement {
     },
     VarDecl {
         name: Arc<str>,
+        name_span: Span,
         mutable: bool, // true for `let`, false for `const`
         type_ann: Option<TypeAnnotation>,
         init: Option<Expr>,
@@ -189,6 +199,7 @@ pub enum Statement {
     },
     ForOf {
         name: Arc<str>,
+        name_span: Span,
         iterable: Expr,
         body: Box<Statement>,
         span: Span,
@@ -206,6 +217,7 @@ pub enum Statement {
     FunDecl {
         async_: bool,
         name: Arc<str>,
+        name_span: Span,
         params: Vec<FunParam>,
         rest_param: Option<TypedParam>,
         return_type: Option<TypeAnnotation>,
@@ -230,6 +242,7 @@ pub enum Statement {
     Try {
         body: Box<Statement>,
         catch_param: Option<Arc<str>>,
+        catch_param_span: Option<Span>,
         catch_body: Option<Box<Statement>>,
         finally_body: Option<Box<Statement>>,
         span: Span,
@@ -243,6 +256,31 @@ pub enum Statement {
         declaration: Box<ExportDeclaration>,
         span: Span,
     },
+    /// `type Name = Type` (erased at runtime; for checker / declaration files).
+    TypeAlias {
+        name: Arc<str>,
+        name_span: Span,
+        ty: TypeAnnotation,
+        span: Span,
+    },
+    /// `declare let name: T` or `declare const name: T`
+    DeclareVar {
+        name: Arc<str>,
+        name_span: Span,
+        type_ann: Option<TypeAnnotation>,
+        const_: bool,
+        span: Span,
+    },
+    /// `declare [async] function name(...): R` (no body).
+    DeclareFun {
+        async_: bool,
+        name: Arc<str>,
+        name_span: Span,
+        params: Vec<FunParam>,
+        rest_param: Option<TypedParam>,
+        return_type: Option<TypeAnnotation>,
+        span: Span,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -550,6 +588,39 @@ pub enum UnaryOp {
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum MemberProp {
-    Name(Arc<str>),
+    /// Property name in `obj.prop` / `obj?.prop` (span covers **prop** only).
+    Name {
+        name: Arc<str>,
+        span: Span,
+    },
     Expr(Box<Expr>), // for computed property
 }
+
+impl Statement {
+    /// Source span covering this statement (including nested bodies where applicable).
+    pub fn span(&self) -> Span {
+        match self {
+            Statement::Block { span, .. }
+            | Statement::VarDecl { span, .. }
+            | Statement::VarDeclDestructure { span, .. }
+            | Statement::ExprStmt { span, .. }
+            | Statement::If { span, .. }
+            | Statement::While { span, .. }
+            | Statement::For { span, .. }
+            | Statement::ForOf { span, .. }
+            | Statement::Return { span, .. }
+            | Statement::Break { span, .. }
+            | Statement::Continue { span, .. }
+            | Statement::FunDecl { span, .. }
+            | Statement::Switch { span, .. }
+            | Statement::DoWhile { span, .. }
+            | Statement::Throw { span, .. }
+            | Statement::Try { span, .. }
+            |             Statement::Import { span, .. }
+            | Statement::Export { span, .. }
+            | Statement::TypeAlias { span, .. }
+            | Statement::DeclareVar { span, .. }
+            | Statement::DeclareFun { span, .. } => *span,
+        }
+    }
+}

package/crates/tish_build_utils/Cargo.toml

@@ -5,3 +5,7 @@ edition = "2021"
 description = "Shared build utilities for Tish (workspace discovery, path resolution)"
 license-file = { workspace = true }
 repository = { workspace = true }
+
+[dependencies]
+# Bundled `protoc` for nested `cargo build` (Lance / prost-build) when none is on PATH.
+protoc-bin-vendored = "3"

package/crates/tish_build_utils/src/lib.rs

@@ -137,6 +137,39 @@ fn tish_root_from_project_cargo_files(mut start: PathBuf) -> Option<PathBuf> {
 /// Returns the directory containing the workspace Cargo.toml (with [workspace]).
 /// Used when building native binaries, WASM, or locating runtime crates.
 pub fn find_workspace_root() -> Result<PathBuf, String> {
+    // Strategy 0: explicit checkout (e.g. tish-hub `npm run dev` / native build from a JS-only tree)
+    if let Ok(root) = std::env::var("TISHLANG_WORKSPACE") {
+        let trimmed = root.trim();
+        if !trimmed.is_empty() {
+            let p = PathBuf::from(trimmed);
+            if p.is_dir() && is_tish_workspace_root(&p) {
+                return p.canonicalize().map_err(|e| {
+                    format!(
+                        "TISHLANG_WORKSPACE is set but not a usable directory: {}",
+                        e
+                    )
+                });
+            }
+            // Non-empty but invalid: fall through (sibling `tish/` discovery may still apply).
+        }
+    }
+
+    // Strategy 0b: monorepo layout `…/<parent>/tish-hub` (cwd) next to `…/<parent>/tish` (language repo).
+    // Works without `TISHLANG_WORKSPACE` so older `tish` binaries still find the compiler tree.
+    if let Ok(mut dir) = std::env::current_dir() {
+        for _ in 0..24 {
+            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)
+                });
+            }
+            if !dir.pop() {
+                break;
+            }
+        }
+    }
+
     // Strategy 1: CARGO_MANIFEST_DIR (works during cargo build/run from workspace)
     if let Ok(manifest_dir) = std::env::var("CARGO_MANIFEST_DIR") {
         let path = PathBuf::from(&manifest_dir);
@@ -301,18 +334,70 @@ pub fn create_build_dir(prefix: &str, out_name: &str) -> Result<PathBuf, String>
     Ok(build_dir)
 }
 
+/// `PROTOC` for prost-build in transitive crates (e.g. lance-encoding) during nested `cargo build`.
+/// Respects an existing `PROTOC`, then `protoc` on `PATH`, then `protoc-bin-vendored`.
+fn protoc_for_nested_cargo() -> Option<PathBuf> {
+    // Empty or non-file PROTOC must not short-circuit: prost-build treats "" like a missing binary.
+    if let Some(v) = std::env::var_os("PROTOC") {
+        if !v.is_empty() {
+            let p = PathBuf::from(&v);
+            if p.is_file() {
+                return None;
+            }
+        }
+    }
+    // Prefer vendored protoc over PATH: a broken or non-executable `protoc` on PATH still passes `is_file()`.
+    if let Ok(p) = protoc_bin_vendored::protoc_bin_path() {
+        return Some(p);
+    }
+    let ext = if cfg!(windows) { ".exe" } else { "" };
+    let name = format!("protoc{}", ext);
+    if let Some(paths) = std::env::var_os("PATH") {
+        for dir in std::env::split_paths(&paths) {
+            let candidate = dir.join(&name);
+            if candidate.is_file() {
+                return Some(candidate);
+            }
+        }
+    }
+    None
+}
+
 /// 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> {
     let target_dir = target_dir
         .map(|p| p.to_path_buf())
         .unwrap_or_else(|| build_dir.join("target"));
-    let output = Command::new("cargo")
-        .args(["build", "--release", "--target-dir"])
+    // 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 mut cmd = Command::new("cargo");
+    cmd.args(["build", "--release", "--target-dir"])
         .arg(&target_dir)
         .current_dir(build_dir)
         .env_remove("CARGO_TARGET_DIR")
+        .env_remove("RUSTC_WRAPPER")
+        .env_remove("RUSTC_WORKSPACE_WRAPPER")
+        .env_remove("CARGO_BUILD_RUSTC_WRAPPER")
         .env("CARGO_TERM_PROGRESS", "always")
+        .env("RUSTFLAGS", &merged_rustflags);
+    if let Some(protoc) = protoc_for_nested_cargo() {
+        cmd.env("PROTOC", protoc);
+    }
+    let output = cmd
         .output()
         .map_err(|e| format!("Failed to run cargo: {}", e))?;
 
@@ -327,6 +412,24 @@ pub fn run_cargo_build(build_dir: &Path, target_dir: Option<&Path>) -> Result<()
     Ok(())
 }
 
+#[cfg(test)]
+mod protoc_tests {
+    use super::*;
+
+    #[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()
+        );
+    }
+}
+
 /// Find the built binary in target/release.
 pub fn find_release_binary(binary_dir: &Path, bin_name: &str) -> Result<PathBuf, String> {
     let binary_no_ext = binary_dir.join(bin_name);