@tishlang/tish 1.5.0 → 1.6.0

package/crates/tish/Cargo.toml

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

package/crates/tish/tests/cargo_example_compile.rs

@@ -0,0 +1,65 @@
+//! `cargo:` + `tish.rustDependencies` using the in-repo fixture at `tests/fixtures/cargo_example_project/`
+//! (same layout as the standalone `tish-cargo-example` template).
+
+use std::path::PathBuf;
+
+use tishlang_ast::Statement;
+use tishlang_compile::{compile_project_full, merge_modules, resolve_project};
+
+fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
+    if cli_features.is_empty() {
+        let mut v: Vec<String> = tishlang_vm::all_compiled_capabilities().into_iter().collect();
+        v.sort();
+        v
+    } else {
+        cli_features.to_vec()
+    }
+}
+
+#[test]
+fn resolve_and_merge_cargo_example_fixture() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let input_path = manifest_dir
+        .join("tests/fixtures/cargo_example_project/src/main.tish")
+        .canonicalize()
+        .expect("cargo_example_project test fixture");
+    let project_root = input_path.parent().map(|p| {
+        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+            p.parent().unwrap_or(p)
+        } else {
+            p
+        }
+    });
+    let modules = resolve_project(&input_path, project_root).unwrap();
+    assert_eq!(modules.len(), 1, "expected single entry module");
+    let first = &modules[0].program.statements[0];
+    let Statement::Import { from, .. } = first else {
+        panic!("expected import, got {:?}", first);
+    };
+    assert_eq!(from.as_ref(), "cargo:demo_shim");
+    merge_modules(modules).unwrap();
+}
+
+#[test]
+fn compile_project_full_cargo_example_fixture() {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let example_main = manifest_dir
+        .join("tests/fixtures/cargo_example_project/src/main.tish")
+        .canonicalize()
+        .expect("cargo_example_project test fixture");
+    let input_path = example_main;
+    let project_root = input_path.parent().map(|p| {
+        if p.file_name().and_then(|n| n.to_str()) == Some("src") {
+            p.parent().unwrap_or(p)
+        } else {
+            p
+        }
+    });
+    let features = native_build_features_from_cli(&[]);
+    let r = compile_project_full(&input_path, project_root, &features, true);
+    assert!(
+        r.is_ok(),
+        "compile_project_full failed: {:?}",
+        r.map_err(|e| e.message)
+    );
+}

package/crates/tish/tests/fixtures/cargo_example_project/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "2"
+members = ["crates/demo-shim"]

package/crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "demo_shim"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["rlib"]
+
+[dependencies]
+# Fixture lives at crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim → repo crates/tish_core
+tishlang_core = { path = "../../../../../../../crates/tish_core" }

package/crates/tish/tests/fixtures/cargo_example_project/crates/demo-shim/src/lib.rs

@@ -0,0 +1,12 @@
+//! Rust exports for `import { … } from 'cargo:demo_shim'` (test fixture).
+
+use std::sync::Arc;
+use tishlang_core::Value;
+
+pub fn greet(args: &[Value]) -> Value {
+    let name = match args.first() {
+        Some(Value::String(s)) => s.as_ref(),
+        _ => "world",
+    };
+    Value::String(Arc::from(format!("Hello, {}!", name)))
+}

package/crates/tish/tests/fixtures/cargo_example_project/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "tish-cargo-example-fixture",
+  "version": "0.0.0",
+  "private": true,
+  "tish": {
+    "rustDependencies": {
+      "demo_shim": { "path": "./crates/demo-shim" }
+    }
+  }
+}

package/crates/tish/tests/fixtures/cargo_example_project/src/main.tish

@@ -0,0 +1,3 @@
+import { greet } from 'cargo:demo_shim'
+
+console.log(greet('from cargo'))

package/crates/tish_build_utils/src/lib.rs

@@ -202,6 +202,21 @@ pub fn find_workspace_root() -> Result<PathBuf, String> {
     Err("Cannot find Tish workspace root. Run from workspace root or use cargo run.".to_string())
 }
 
+/// Path to `crates/tish_runtime` inside a locally installed `@tishlang/tish` npm package.
+pub fn npm_package_runtime_path(project_root: &Path) -> Option<PathBuf> {
+    let p = project_root
+        .join("node_modules")
+        .join("@tishlang")
+        .join("tish")
+        .join("crates")
+        .join("tish_runtime");
+    if p.is_dir() {
+        Some(p)
+    } else {
+        None
+    }
+}
+
 /// Find the path to the tishlang_runtime crate.
 ///
 /// Returns a canonical path string suitable for Cargo.toml path dependencies.
@@ -217,6 +232,24 @@ pub fn find_runtime_path() -> Result<String, String> {
         .map(|p| p.display().to_string().replace('\\', "/"))
 }
 
+/// Resolve `tishlang_runtime` for a Cargo build, preferring the npm install under `project_root`.
+///
+/// When a Tish app lives next to a checkout of the language repo (e.g. `…/tish/tish-cargo-example`),
+/// [`find_workspace_root`] can return the checkout while `rustDependencies` point at
+/// `node_modules/@tishlang/tish/crates/tish_core`. Using the npm tree for **both** runtime and shim
+/// avoids Cargo lockfile "package collision" for the same crate name/version at two paths.
+pub fn find_runtime_path_for_project(project_root: Option<&Path>) -> Result<String, String> {
+    if let Some(root) = project_root {
+        if let Some(rt) = npm_package_runtime_path(root) {
+            return rt
+                .canonicalize()
+                .map_err(|e| format!("Cannot canonicalize tishlang_runtime (npm): {}", e))
+                .map(|p| p.display().to_string().replace('\\', "/"));
+        }
+    }
+    find_runtime_path()
+}
+
 /// Crate package name -> directory name (directories kept as tish_* for historical reasons).
 const CRATE_NAME_TO_DIR: &[(&str, &str)] = &[
     ("tishlang_runtime", "tish_runtime"),

package/crates/tish_compile/Cargo.toml

@@ -22,3 +22,4 @@ tishlang_ui = { path = "../tish_ui", version = ">=0.1", default-features = false
 serde_json = "1.0"
 
 [dev-dependencies]
+tempfile = "3"

package/crates/tish_compile/src/codegen.rs

@@ -393,19 +393,27 @@ pub fn compile_project(
     project_root: Option<&Path>,
     features: &[String],
 ) -> Result<String, CompileError> {
-    let (rust, _, _) = compile_project_full(entry_path, project_root, features, true)?;
+    let (rust, _, _, _) = compile_project_full(entry_path, project_root, features, true)?;
     Ok(rust)
 }
 
-/// Compile a project and return Rust code, resolved native modules, and the **effective** feature list
-/// (CLI features plus any inferred from `tish:fs` / `tish:http` / … imports). Pass this list to
-/// `tishlang_runtime` when linking (e.g. `build_via_cargo`) so Cargo `features` match codegen.
+/// Compile a project and return Rust code, resolved native modules, the **effective** feature list
+/// (CLI features plus any inferred from `tish:fs` / `tish:http` / … imports), and native build
+/// artifacts (Cargo dep lines, optional `generated_native.rs` source, init strategy per spec).
 pub fn compile_project_full(
     entry_path: &Path,
     project_root: Option<&Path>,
     features: &[String],
     optimize: bool,
-) -> Result<(String, Vec<crate::resolve::ResolvedNativeModule>, Vec<String>), CompileError> {
+) -> Result<
+    (
+        String,
+        Vec<crate::resolve::ResolvedNativeModule>,
+        Vec<String>,
+        crate::resolve::NativeBuildArtifacts,
+    ),
+    CompileError,
+> {
     use crate::resolve;
     let root = project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
     let modules = resolve::resolve_project(entry_path, project_root)
@@ -416,14 +424,23 @@ pub fn compile_project_full(
         .map_err(|e| CompileError { message: e, span: None })?;
     let native_modules = resolve::resolve_native_modules(&merged, root)
         .map_err(|e| CompileError { message: e, span: None })?;
+    let native_build = resolve::compute_native_build_artifacts(&merged, root, &native_modules)
+        .map_err(|e| CompileError { message: e, span: None })?;
     let mut all_features: Vec<String> = features.to_vec();
     for f in resolve::extract_native_import_features(&merged) {
         if !all_features.contains(&f) {
             all_features.push(f);
         }
     }
-    let rust = compile_with_native_modules(&merged, project_root, &all_features, &native_modules, optimize)?;
-    Ok((rust, native_modules, all_features))
+    let rust = compile_with_native_modules(
+        &merged,
+        project_root,
+        &all_features,
+        &native_modules,
+        &native_build.native_init,
+        optimize,
+    )?;
+    Ok((rust, native_modules, all_features, native_build))
 }
 
 /// Compile with explicit feature flags. When features are provided, codegen uses them
@@ -433,7 +450,8 @@ pub fn compile_with_features(
     project_root: Option<&Path>,
     features: &[String],
 ) -> Result<String, CompileError> {
-    compile_with_native_modules(program, project_root, features, &[], true)
+    let empty = std::collections::HashMap::new();
+    compile_with_native_modules(program, project_root, features, &[], &empty, true)
 }
 
 /// Compile with resolved native modules. Native imports emit calls to the module crates directly.
@@ -442,16 +460,30 @@ pub fn compile_with_native_modules(
     project_root: Option<&Path>,
     features: &[String],
     native_modules: &[crate::resolve::ResolvedNativeModule],
+    native_init: &std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     optimize: bool,
 ) -> Result<String, CompileError> {
     let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
     // Type-inference pass: fills in `type_ann` on unannotated VarDecl nodes where
     // the type is unambiguous (literals, arithmetic of typed vars, etc.).
     let program = crate::infer::infer_program(&program);
-    let map: std::collections::HashMap<String, (String, String)> = native_modules
-        .iter()
-        .map(|m| (m.spec.clone(), (m.crate_name.clone(), m.export_fn.clone())))
-        .collect();
+    let map: std::collections::HashMap<String, crate::resolve::NativeModuleInit> =
+        if native_init.is_empty() {
+            native_modules
+                .iter()
+                .map(|m| {
+                    (
+                        m.spec.clone(),
+                        crate::resolve::NativeModuleInit::Legacy {
+                            crate_name: m.crate_name.clone(),
+                            export_fn: m.export_fn.clone(),
+                        },
+                    )
+                })
+                .collect()
+        } else {
+            native_init.clone()
+        };
     let mut g = Codegen::new_with_native_modules(project_root, features, map);
     g.emit_program(&program)?;
     Ok(g.output)
@@ -465,8 +497,8 @@ struct Codegen {
     project_root: Option<std::path::PathBuf>,
     /// Requested features (http, process, fs, regex, polars). When non-empty, used instead of #[cfg].
     features: std::collections::HashSet<String>,
-    /// spec -> (crate_name, export_fn) for native modules resolved via package.json
-    native_module_map: std::collections::HashMap<String, (String, String)>,
+    /// spec -> native init strategy (legacy adapter object vs generated `generated_native` wrapper)
+    native_module_init: std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     /// Stack: true = async Rust context (run body), false = sync closure (Tish fn body)
     async_context_stack: Vec<bool>,
     loop_stack: Vec<(String, Option<String>)>, // (break_label, continue_update) for innermost loop
@@ -497,7 +529,7 @@ impl Codegen {
     fn new_with_native_modules(
         project_root: Option<&Path>,
         features: &[String],
-        native_module_map: std::collections::HashMap<String, (String, String)>,
+        native_module_init: std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     ) -> Self {
         let features: std::collections::HashSet<String> = features.iter().cloned().collect();
         Self {
@@ -507,7 +539,7 @@ impl Codegen {
             is_async: false,
             project_root: project_root.map(|p| p.to_path_buf()),
             features,
-            native_module_map,
+            native_module_init,
             async_context_stack: Vec::new(),
             loop_stack: Vec::new(),
             function_scope_stack: vec![Vec::new()], // Start with global scope
@@ -540,12 +572,21 @@ impl Codegen {
         if is_builtin_native_spec(spec) {
             return self.builtin_native_module_rust_init(spec, export_name);
         }
-        self.native_module_map.get(spec).map(|(crate_name, export_fn)| {
+        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().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
-                crate_name, export_fn, export_name
+                "{{ let _ns = {}; match _ns {{ Value::Object(ref _o) => _o.borrow().get({:?}).cloned().unwrap_or(Value::Null), _ => Value::Null }} }}",
+                init_expr, export_name
             )
         })
     }
@@ -1779,7 +1820,15 @@ impl Codegen {
             }
             Expr::Call { callee, args, .. } => {
                 // Compile-time embed: Polars.read_csv("<literal path>") when file exists
-                if let Some((crate_name, _)) = self.native_module_map.get("tish:polars") {
+                if let Some(init) = self.native_module_init.get("tish:polars") {
+                    let crate_name = match init {
+                        crate::resolve::NativeModuleInit::Legacy { crate_name, .. } => {
+                            crate_name.as_str()
+                        }
+                        crate::resolve::NativeModuleInit::Generated { shim_crate, .. } => {
+                            shim_crate.as_str()
+                        }
+                    };
                     if let (Some(root), Some(CallArg::Expr(first_arg))) =
                         (self.project_root.as_ref(), args.first())
                     {

package/crates/tish_compile/src/lib.rs

@@ -13,9 +13,12 @@ pub use codegen::{
 };
 pub use codegen::CompileError;
 pub use resolve::{
-    detect_cycles, extract_native_import_features, has_external_native_imports, has_native_imports,
-    is_builtin_native_spec, merge_modules, resolve_native_modules, resolve_project,
-    resolve_project_from_stdin, ResolvedNativeModule,
+    cargo_export_fn_name, compute_native_build_artifacts, detect_cycles, export_name_to_rust_ident,
+    extract_native_import_features, format_rust_dependencies_toml, generate_native_wrapper_rs,
+    has_external_native_imports, has_native_imports, infer_native_module_exports,
+    is_builtin_native_spec, is_cargo_native_spec, merge_modules, read_project_tish_config,
+    resolve_native_modules, resolve_project, resolve_project_from_stdin, NativeBuildArtifacts,
+    NativeModuleInit, ResolvedNativeModule,
 };
 pub use types::{RustType, TypeContext};
 
@@ -108,7 +111,7 @@ fn factory() {
             .into_iter()
             .map(String::from)
             .collect::<Vec<_>>();
-        let (rust, _, _) = compile_project_full(&bench, bench.parent(), &features, true).unwrap();
+        let (rust, _, _, _) = compile_project_full(&bench, bench.parent(), &features, true).unwrap();
         // outerVar = 42 is inferred as f64; f64 is Copy so no .clone() is emitted.
         assert!(
             rust.contains("let mut outerVar: f64"),

package/crates/tish_compile/src/resolve.rs

@@ -1,5 +1,5 @@
 //! Module resolver: resolves relative imports, builds dependency graph, detects cycles.
-//! Supports native imports: tish:egui, tish:polars, @scope/pkg (via package.json).
+//! Supports native imports: `tish:…`, `cargo:…`, `@scope/pkg` (via package.json).
 
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
@@ -16,6 +16,33 @@ pub struct ResolvedNativeModule {
     pub crate_name: String,
     pub crate_path: PathBuf,
     pub export_fn: String,
+    /// When false, omit `path = …` in the generated Cargo.toml (crate comes from `tish.rustDependencies` only).
+    pub use_path_dependency: bool,
+}
+
+/// How codegen links a native import to Rust (`generateNativeWrapper` for `tish:*`; `cargo:*` always generated).
+#[derive(Debug, Clone)]
+pub enum NativeModuleInit {
+    /// Call `external_crate::export_fn()` and read named exports from the returned object.
+    Legacy {
+        crate_name: String,
+        export_fn: String,
+    },
+    /// Call `crate::generated_native::export_fn()` — object built from per-export fns on `shim_crate`.
+    Generated {
+        shim_crate: String,
+        export_fn: String,
+    },
+}
+
+/// Extra native build inputs produced alongside Rust source (Cargo merge + optional wrapper).
+#[derive(Debug, Clone)]
+pub struct NativeBuildArtifacts {
+    /// Extra `[dependencies]` lines from `tish.rustDependencies`.
+    pub rust_dependencies_toml: String,
+    /// Generated `generated_native.rs` when using [`NativeModuleInit::Generated`].
+    pub generated_native_rs: Option<String>,
+    pub native_init: std::collections::HashMap<String, NativeModuleInit>,
 }
 
 /// Node-compatible aliases for built-in modules (fs -> tish:fs, etc.).
@@ -45,6 +72,7 @@ pub fn is_builtin_native_spec(spec: &str) -> bool {
 
 /// Resolve all native imports in a merged program via package.json lookup.
 /// Built-in modules (tish:fs, tish:http, tish:process) are skipped - they use tishlang_runtime directly.
+/// Handles both lowered `NativeModuleLoad` (merged modules) and raw `import { … } from 'tish:…'`.
 pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<Vec<ResolvedNativeModule>, String> {
     let root_canon = project_root
         .canonicalize()
@@ -52,25 +80,93 @@ pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<
     let mut seen = HashSet::new();
     let mut modules = Vec::new();
     for stmt in &program.statements {
-        if let Statement::VarDecl {
-            init: Some(Expr::NativeModuleLoad { spec, .. }),
-            ..
-        } = stmt
-        {
-            let s = spec.as_ref();
-            if is_builtin_native_spec(s) {
-                continue; // Built-ins use tishlang_runtime, no package.json lookup
+        let specs: Vec<String> = match stmt {
+            Statement::VarDecl {
+                init: Some(Expr::NativeModuleLoad { spec, .. }),
+                ..
+            } => vec![spec.as_ref().to_string()],
+            Statement::Import { from, .. } if is_native_import(from.as_ref()) => {
+                vec![normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string())]
+            }
+            _ => continue,
+        };
+        for s in specs {
+            if is_builtin_native_spec(&s) {
+                continue;
             }
-            if !seen.insert(s.to_string()) {
+            if !seen.insert(s.clone()) {
                 continue;
             }
-            let m = resolve_native_module(s, &root_canon)?;
+            let m = if s.starts_with("cargo:") {
+                resolve_cargo_native_module(&s, &root_canon)?
+            } else {
+                resolve_native_module(&s, &root_canon)?
+            };
             modules.push(m);
         }
     }
     Ok(modules)
 }
 
+/// True for `cargo:…` specs (Cargo-backed imports; Rust native backend only).
+pub fn is_cargo_native_spec(spec: &str) -> bool {
+    spec.starts_with("cargo:")
+}
+
+/// Stable Rust symbol for the generated namespace function, e.g. `cargo:my-crate` → `cargo_native_my_crate_object`.
+pub fn cargo_export_fn_name(spec: &str) -> String {
+    let tail = spec.strip_prefix("cargo:").unwrap_or(spec);
+    let mut out = String::from("cargo_native_");
+    for c in tail.chars() {
+        if c.is_ascii_alphanumeric() {
+            out.push(c);
+        } else {
+            out.push('_');
+        }
+    }
+    if out == "cargo_native_" {
+        out.push_str("unnamed");
+    }
+    out.push_str("_object");
+    out
+}
+
+fn resolve_cargo_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNativeModule, String> {
+    let tail = spec
+        .strip_prefix("cargo:")
+        .ok_or_else(|| format!("Invalid cargo native spec: {}", spec))?;
+    if tail.is_empty() {
+        return Err("cargo: import needs a dependency name, e.g. import { x } from 'cargo:serde_json'".into());
+    }
+    let dep_key = tail.to_string();
+    let tish = read_project_tish_config(project_root);
+    let rust_deps = tish.get("rustDependencies").and_then(|v| v.as_object()).ok_or_else(|| {
+        format!(
+            "cargo:{} requires package.json \"tish\": {{ \"rustDependencies\": {{ \"{}\": \"…\" }} }}",
+            tail, dep_key
+        )
+    })?;
+    if !rust_deps.contains_key(&dep_key) {
+        return Err(format!(
+            "cargo:{}: add \"{}\" to tish.rustDependencies in package.json (version string or inline table)",
+            tail, dep_key
+        ));
+    }
+    let crate_name = dep_key.replace('-', "_");
+    let export_fn = cargo_export_fn_name(spec);
+    let crate_path = project_root
+        .canonicalize()
+        .unwrap_or_else(|_| project_root.to_path_buf());
+    Ok(ResolvedNativeModule {
+        spec: spec.to_string(),
+        package_name: dep_key.clone(),
+        crate_name,
+        crate_path,
+        export_fn,
+        use_path_dependency: false,
+    })
+}
+
 fn resolve_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNativeModule, String> {
     let package_name = if spec.starts_with("tish:") {
         format!("tish-{}", spec.strip_prefix("tish:").unwrap_or(spec))
@@ -110,6 +206,236 @@ fn resolve_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNati
         crate_name: raw_crate.replace('-', "_"),
         crate_path,
         export_fn,
+        use_path_dependency: true,
+    })
+}
+
+/// Read the `tish` object from the project root `package.json` (empty JSON object if missing).
+pub fn read_project_tish_config(project_root: &Path) -> serde_json::Value {
+    let path = project_root.join("package.json");
+    let Ok(content) = std::fs::read_to_string(&path) else {
+        return serde_json::json!({});
+    };
+    let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) else {
+        return serde_json::json!({});
+    };
+    json.get("tish").cloned().unwrap_or_else(|| serde_json::json!({}))
+}
+
+fn resolve_cargo_path_for_toml(project_root: &Path, raw: &str) -> String {
+    let p = Path::new(raw);
+    let resolved = if p.is_absolute() {
+        p.to_path_buf()
+    } else {
+        project_root.join(p)
+    };
+    let resolved = resolved.canonicalize().unwrap_or(resolved);
+    resolved.display().to_string().replace('\\', "/")
+}
+
+fn json_to_cargo_inline_value(v: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+    match v {
+        serde_json::Value::String(s) => Ok(format!("{:?}", s.as_str())),
+        serde_json::Value::Bool(b) => Ok(b.to_string()),
+        serde_json::Value::Number(n) => Ok(n.to_string()),
+        serde_json::Value::Array(arr) => {
+            let mut inner = Vec::new();
+            for item in arr {
+                inner.push(json_to_cargo_inline_value(item, project_root)?);
+            }
+            Ok(format!("[{}]", inner.join(", ")))
+        }
+        serde_json::Value::Object(map) => {
+            let mut parts = Vec::new();
+            for (k, v) in map {
+                let rhs = if k == "path" && v.as_str().is_some() {
+                    let s = v.as_str().unwrap();
+                    format!("{:?}", resolve_cargo_path_for_toml(project_root, s))
+                } else {
+                    json_to_cargo_inline_value(v, project_root)?
+                };
+                parts.push(format!("{} = {}", k, rhs));
+            }
+            Ok(format!("{{ {} }}", parts.join(", ")))
+        }
+        serde_json::Value::Null => Err("null is not valid in a Cargo dependency value".to_string()),
+    }
+}
+
+/// Serialize `tish.rustDependencies` from project `package.json` into Cargo.toml `[dependencies]` lines.
+/// Relative `path = "…"` entries in inline tables are resolved against `project_root` so the temp build crate can find them.
+pub fn format_rust_dependencies_toml(tish: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+    let Some(obj) = tish.get("rustDependencies").and_then(|v| v.as_object()) else {
+        return Ok(String::new());
+    };
+    let mut out = String::new();
+    for (name, val) in obj {
+        match val {
+            serde_json::Value::String(_) | serde_json::Value::Object(_) => {
+                out.push_str(&format!(
+                    "{} = {}\n",
+                    name,
+                    json_to_cargo_inline_value(val, project_root)?
+                ));
+            }
+            _ => {
+                return Err(format!(
+                    "tish.rustDependencies.{} must be a string (version) or object (inline table)",
+                    name
+                ));
+            }
+        }
+    }
+    Ok(out)
+}
+
+/// Map a Tish export name to a Rust identifier (e.g. `readFile` → `read_file`) for shim crate symbols.
+pub fn export_name_to_rust_ident(export_name: &str) -> String {
+    let mut out = String::new();
+    for (i, c) in export_name.chars().enumerate() {
+        if c.is_uppercase() && i > 0 {
+            out.push('_');
+        }
+        for lower in c.to_lowercase() {
+            out.push(lower);
+        }
+    }
+    if out.is_empty() {
+        "native_export".to_string()
+    } else {
+        out
+    }
+}
+
+/// Collect `(spec, export_name)` for every non-builtin native import in the program.
+pub fn infer_native_module_exports(program: &Program) -> HashMap<String, HashSet<String>> {
+    let mut map: HashMap<String, HashSet<String>> = HashMap::new();
+    for stmt in &program.statements {
+        match stmt {
+            Statement::VarDecl {
+                init: Some(Expr::NativeModuleLoad { spec, export_name, .. }),
+                ..
+            } => {
+                let s = spec.as_ref();
+                if is_builtin_native_spec(s) {
+                    continue;
+                }
+                map.entry(s.to_string())
+                    .or_default()
+                    .insert(export_name.to_string());
+            }
+            Statement::Import { specifiers, from, .. } if is_native_import(from.as_ref()) => {
+                let spec = normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string());
+                if is_builtin_native_spec(&spec) {
+                    continue;
+                }
+                for sp in specifiers {
+                    if let ImportSpecifier::Named { name, .. } = sp {
+                        map.entry(spec.clone())
+                            .or_default()
+                            .insert(name.to_string());
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    map
+}
+
+/// Emit `generated_native.rs` for [`NativeModuleInit::Generated`] modules.
+pub fn generate_native_wrapper_rs(
+    modules: &[ResolvedNativeModule],
+    inferred: &HashMap<String, HashSet<String>>,
+    init_by_spec: &HashMap<String, NativeModuleInit>,
+) -> String {
+    let mut file = String::from(
+        "//! Generated by `tish build` — do not edit.\n\
+         use std::cell::RefCell;\n\
+         use std::rc::Rc;\n\
+         use std::sync::Arc;\n\
+         use tishlang_runtime::{ObjectMap, Value};\n\n",
+    );
+    let mut any = false;
+    for m in modules {
+        let Some(NativeModuleInit::Generated { shim_crate, export_fn }) = init_by_spec.get(&m.spec) else {
+            continue;
+        };
+        let Some(names) = inferred.get(&m.spec) else {
+            continue;
+        };
+        if names.is_empty() {
+            continue;
+        }
+        any = true;
+        let mut keys: Vec<_> = names.iter().cloned().collect();
+        keys.sort();
+        file.push_str(&format!("pub fn {}() -> Value {{\n", export_fn));
+        file.push_str("    let mut m = ObjectMap::default();\n");
+        for export_name in keys {
+            let rust_fn = export_name_to_rust_ident(&export_name);
+            let key_lit = format!("{:?}", export_name);
+            file.push_str(&format!(
+                "    m.insert(Arc::from({}), Value::Function(Rc::new(|args: &[Value]| {{\n        {}::{}(args)\n    }})));\n",
+                key_lit, shim_crate, rust_fn
+            ));
+        }
+        file.push_str("    Value::Object(Rc::new(RefCell::new(m)))\n}\n\n");
+    }
+    if !any {
+        return String::new();
+    }
+    file
+}
+
+/// Combine project `package.json`, inferred exports, and resolved native modules into build artifacts.
+pub fn compute_native_build_artifacts(
+    program: &Program,
+    project_root: &Path,
+    native_modules: &[ResolvedNativeModule],
+) -> Result<NativeBuildArtifacts, String> {
+    let tish = read_project_tish_config(project_root);
+    let rust_dependencies_toml = format_rust_dependencies_toml(&tish, project_root)?;
+    let inferred = infer_native_module_exports(program);
+    let gen_tish = tish
+        .get("generateNativeWrapper")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false);
+
+    let mut native_init: HashMap<String, NativeModuleInit> = HashMap::new();
+    for m in native_modules {
+        let use_gen = if is_cargo_native_spec(&m.spec) {
+            inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+        } else {
+            gen_tish && inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+        };
+        let init = if use_gen {
+            NativeModuleInit::Generated {
+                shim_crate: m.crate_name.clone(),
+                export_fn: m.export_fn.clone(),
+            }
+        } else {
+            NativeModuleInit::Legacy {
+                crate_name: m.crate_name.clone(),
+                export_fn: m.export_fn.clone(),
+            }
+        };
+        native_init.insert(m.spec.clone(), init);
+    }
+
+    let generated_native_rs = {
+        let s = generate_native_wrapper_rs(native_modules, &inferred, &native_init);
+        if s.trim().is_empty() {
+            None
+        } else {
+            Some(s)
+        }
+    };
+
+    Ok(NativeBuildArtifacts {
+        rust_dependencies_toml,
+        generated_native_rs,
+        native_init,
     })
 }
 
@@ -151,16 +477,25 @@ fn read_package_name(pkg_path: &Path) -> Option<String> {
     json.get("name").and_then(|v| v.as_str()).map(String::from)
 }
 
+fn stmt_native_specs(stmt: &Statement) -> Vec<String> {
+    match stmt {
+        Statement::VarDecl {
+            init: Some(Expr::NativeModuleLoad { spec, .. }),
+            ..
+        } => vec![spec.to_string()],
+        Statement::Import { from, .. } if is_native_import(from.as_ref()) => {
+            vec![normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string())]
+        }
+        _ => vec![],
+    }
+}
+
 /// Extract Cargo feature names from native imports in a merged program.
 /// Used to enable tishlang_runtime features based on `import { x } from 'tish:egui'` etc.
 pub fn extract_native_import_features(program: &Program) -> Vec<String> {
     let mut features = std::collections::HashSet::new();
     for stmt in &program.statements {
-        if let Statement::VarDecl {
-            init: Some(Expr::NativeModuleLoad { spec, .. }),
-            ..
-        } = stmt
-        {
+        for spec in stmt_native_specs(stmt) {
             if let Some(f) = native_spec_to_feature(spec.as_ref()) {
                 features.insert(f);
             }
@@ -171,27 +506,17 @@ pub fn extract_native_import_features(program: &Program) -> Vec<String> {
 
 /// Returns true if the merged program contains native imports (tish:*, @scope/pkg).
 pub fn has_native_imports(program: &Program) -> bool {
-    for stmt in &program.statements {
-        if let Statement::VarDecl {
-            init: Some(Expr::NativeModuleLoad { .. }),
-            ..
-        } = stmt
-        {
-            return true;
-        }
-    }
-    false
+    program
+        .statements
+        .iter()
+        .any(|stmt| !stmt_native_specs(stmt).is_empty())
 }
 
 /// Returns true if the merged program contains external native imports (not built-in tish:fs/http/process).
 /// Cranelift/LLVM reject these; bytecode VM supports built-ins only.
 pub fn has_external_native_imports(program: &Program) -> bool {
     for stmt in &program.statements {
-        if let Statement::VarDecl {
-            init: Some(Expr::NativeModuleLoad { spec, .. }),
-            ..
-        } = stmt
-        {
+        for spec in stmt_native_specs(stmt) {
             if !is_builtin_native_spec(spec.as_ref()) {
                 return true;
             }
@@ -267,10 +592,10 @@ pub fn resolve_project_from_stdin(
 
     for stmt in &program.statements {
         if let Statement::Import { from, .. } = stmt {
-            if is_native_import(from) {
+            if is_native_import(from.as_ref()) {
                 continue;
             }
-            let dep_path = resolve_import_path(from, from_dir, &root_canon)?;
+            let dep_path = resolve_import_path(from.as_ref(), from_dir, &root_canon)?;
             if !path_to_module.contains_key(&dep_path) {
                 load_module_recursive(
                     &dep_path,
@@ -320,10 +645,10 @@ fn load_module_recursive(
     let dir = canonical.parent().unwrap_or(Path::new("."));
     for stmt in &program.statements {
         if let Statement::Import { from, .. } = stmt {
-            if is_native_import(from) {
+            if is_native_import(from.as_ref()) {
                 continue; // Native imports don't load files
             }
-            let dep_path = resolve_import_path(from, dir, project_root)?;
+            let dep_path = resolve_import_path(from.as_ref(), dir, project_root)?;
             if !path_to_module.contains_key(&dep_path) {
                 load_module_recursive(
                     &dep_path,
@@ -344,9 +669,11 @@ fn load_module_recursive(
 /// Returns true for native module imports that don't resolve to files.
 /// - fs, http, process, ws (Node-compatible aliases for tish:fs, tish:http, tish:process, tish:ws)
 /// - tish:egui, tish:polars, etc.
+/// - cargo:… (Cargo `rustDependencies` + generated wrapper; Rust native backend)
 /// - @scope/package (npm-style)
 pub fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
+        || spec.starts_with("cargo:")
         || spec.starts_with('@')
         || matches!(spec, "fs" | "http" | "process" | "ws")
 }
@@ -476,10 +803,10 @@ fn has_cycle_from(
 ) -> Result<bool, String> {
     for stmt in &program.statements {
         if let Statement::Import { from, .. } = stmt {
-            if is_native_import(from) {
+            if is_native_import(from.as_ref()) {
                 continue;
             }
-            let dep_path = resolve_import_path(from, from_dir, Path::new("."))?;
+            let dep_path = resolve_import_path(from.as_ref(), from_dir, Path::new("."))?;
             if let Some(&dep_idx) = path_to_idx.get(&dep_path) {
                 if stack.contains(&dep_idx) {
                     stack.push(dep_idx);
@@ -548,10 +875,11 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
         for stmt in &module.program.statements {
             match stmt {
                 Statement::Import { specifiers, from, span } => {
-                    if is_native_import(from) {
+                    if is_native_import(from.as_ref()) {
                         // Normalize fs/http/process -> tish:fs etc. for Node compatibility
                         let canonical_spec =
-                            normalize_builtin_spec(from).unwrap_or_else(|| from.to_string());
+                            normalize_builtin_spec(from.as_ref())
+                                .unwrap_or_else(|| from.to_string());
                         // Emit VarDecl with NativeModuleLoad for each specifier
                         for spec in specifiers {
                             match spec {
@@ -589,7 +917,7 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                         }
                         continue;
                     }
-                    let dep_path = resolve_import_path(from, dir, Path::new("."))?;
+                    let dep_path = resolve_import_path(from.as_ref(), dir, Path::new("."))?;
                     let dep_path = dep_path
                         .canonicalize()
                         .unwrap_or(dep_path);
@@ -682,3 +1010,53 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
     }
     Ok(Program { statements })
 }
+
+#[cfg(test)]
+mod cargo_spec_tests {
+    use std::sync::Arc;
+
+    use super::cargo_export_fn_name;
+    use super::is_native_import;
+
+    #[test]
+    fn is_native_import_accepts_arc_str_ref() {
+        let from: &Arc<str> = &Arc::from("cargo:demo_shim");
+        assert!(is_native_import(from));
+    }
+
+    #[test]
+    fn detect_cycles_skips_cargo_import() {
+        use super::{detect_cycles, resolve_project};
+        let dir = tempfile::tempdir().expect("tempdir");
+        let p = dir.path().join("main.tish");
+        let src = "import { greet } from 'cargo:demo_shim'\nconsole.log(1)\n";
+        std::fs::write(&p, src).unwrap();
+        let root = dir.path();
+        let modules = resolve_project(&p, Some(root)).unwrap();
+        detect_cycles(&modules).unwrap();
+    }
+
+    #[test]
+    fn merge_modules_skips_cargo_import() {
+        use super::{merge_modules, resolve_project};
+        let dir = tempfile::tempdir().expect("tempdir");
+        let p = dir.path().join("main.tish");
+        let src = "import { greet } from 'cargo:demo_shim'\nconsole.log(1)\n";
+        std::fs::write(&p, src).unwrap();
+        let root = dir.path();
+        let modules = resolve_project(&p, Some(root)).unwrap();
+        merge_modules(modules).unwrap();
+    }
+
+    #[test]
+    fn cargo_export_fn_name_sanitizes() {
+        assert_eq!(
+            cargo_export_fn_name("cargo:serde_json"),
+            "cargo_native_serde_json_object"
+        );
+        assert_eq!(
+            cargo_export_fn_name("cargo:my-crate"),
+            "cargo_native_my_crate_object"
+        );
+    }
+}

package/crates/tish_compiler_wasm/src/resolve_virtual.rs

@@ -33,6 +33,7 @@ fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
+        || spec.starts_with("cargo:")
         || spec.starts_with('@')
         || matches!(spec, "fs" | "http" | "process" | "ws")
 }

package/crates/tish_eval/src/eval.rs

@@ -512,6 +512,11 @@ impl Evaluator {
 
     /// Load and evaluate a module, returning its exports object. Uses cache.
     fn load_module(&mut self, from: &str) -> Result<Value, EvalError> {
+        if from.starts_with("cargo:") {
+            return Err(EvalError::Error(
+                "cargo:… imports are only supported by `tish build` with the Rust native backend.".into(),
+            ));
+        }
         if from.starts_with("tish:") {
             return self.load_builtin_module(from);
         }
@@ -599,6 +604,11 @@ impl Evaluator {
 
     /// Load built-in module (tish:fs, tish:http, tish:process, …) or a virtual module from native crates.
     fn load_builtin_module(&self, spec: &str) -> Result<Value, EvalError> {
+        if spec.starts_with("cargo:") {
+            return Err(EvalError::Error(
+                "cargo:… imports are only supported when compiling with `tish build` and the Rust native backend. They link Cargo crates via package.json tish.rustDependencies and a generated native wrapper — not the interpreter or VM.".into(),
+            ));
+        }
         if let Some(v) = self.virtual_builtins.borrow().get(spec) {
             return Ok(v.clone());
         }

package/crates/tish_native/src/build.rs

@@ -28,11 +28,24 @@ fn runtime_features_for_cargo(features: &[String]) -> Vec<String> {
     out
 }
 
+/// Inject `mod generated_native;` after the crate attribute so the binary crate can call `crate::generated_native::…`.
+fn inject_generated_native_mod(rust_code: &str) -> String {
+    if let Some(pos) = rust_code.find("\n\n") {
+        let (a, b) = rust_code.split_at(pos + 2);
+        format!("{}mod generated_native;\n{}", a, b)
+    } else {
+        format!("{}\n\nmod generated_native;\n", rust_code)
+    }
+}
+
 pub fn build_via_cargo(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,
     output_path: &Path,
     features: &[String],
+    extra_dependencies_toml: &str,
+    generated_native_rs: Option<&str>,
+    project_root: Option<&Path>,
 ) -> Result<(), String> {
     let out_name = output_path
         .file_stem()
@@ -40,7 +53,7 @@ pub fn build_via_cargo(
         .unwrap_or("tish_out");
     let build_dir = tishlang_build_utils::create_build_dir("tish_build", out_name)?;
 
-    let runtime_path = tishlang_build_utils::find_runtime_path()?;
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
 
     let runtime_features = runtime_features_for_cargo(features);
     let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
@@ -59,12 +72,28 @@ pub fn build_via_cargo(
 
     let native_deps: String = native_modules
         .iter()
+        .filter(|m| m.use_path_dependency)
         .map(|m| {
             let path = m.crate_path.display().to_string().replace('\\', "/");
             format!("{} = {{ path = {:?} }}\n", m.package_name, path)
         })
         .collect();
 
+    let mut more_deps = String::new();
+    more_deps.push_str(&tokio_dep);
+    if !native_deps.is_empty() {
+        more_deps.push_str(&format!("\n{}", native_deps));
+    }
+    if !extra_dependencies_toml.trim().is_empty() {
+        more_deps.push_str(&format!("\n{}", extra_dependencies_toml));
+    }
+
+    let rust_main = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+
     let tish_ui_path = std::path::Path::new(&runtime_path)
         .parent()
         .ok_or_else(|| "invalid tishlang_runtime path (no parent)".to_string())?
@@ -96,23 +125,22 @@ codegen-units = 1
 lto = "thin"
 
 [dependencies]
-tishlang_runtime = {{ path = {:?}{} }}{}{}{}
-"#,
+tishlang_runtime = {{ path = {:?}{} }}
+{}{}"#,
         out_name,
         runtime_path,
         features_str,
-        tokio_dep,
-        if native_deps.is_empty() {
-            String::new()
-        } else {
-            format!("\n{}", native_deps)
-        },
+        more_deps,
         ui_dep
     );
 
     fs::write(build_dir.join("Cargo.toml"), cargo_toml)
         .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
-    fs::write(build_dir.join("src/main.rs"), rust_code)
+    if let Some(gen) = generated_native_rs {
+        fs::write(build_dir.join("src/generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(build_dir.join("src/main.rs"), rust_main)
         .map_err(|e| format!("Cannot write main.rs: {}", e))?;
 
     let workspace_target = Path::new(&runtime_path)

package/crates/tish_native/src/lib.rs

@@ -57,21 +57,25 @@ pub fn compile_to_native(
 
     match backend {
         Backend::Rust => {
-            let (rust_code, native_modules, effective_features) = tishlang_compile::compile_project_full(
-                entry_path,
-                project_root,
-                features,
-                optimize,
-            )
-            .map_err(|e| NativeError {
-                message: e.to_string(),
-            })?;
+            let (rust_code, native_modules, effective_features, native_build) =
+                tishlang_compile::compile_project_full(
+                    entry_path,
+                    project_root,
+                    features,
+                    optimize,
+                )
+                .map_err(|e| NativeError {
+                    message: e.to_string(),
+                })?;
 
             crate::build::build_via_cargo(
                 &rust_code,
                 native_modules,
                 output_path,
                 &effective_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
+                project_root,
             )
             .map_err(|e| NativeError { message: e })
         }
@@ -96,7 +100,7 @@ pub fn compile_to_native(
 
             if tishlang_compile::has_external_native_imports(&program) {
                 return Err(NativeError {
-                    message: "Cranelift backend does not support external native imports (tish:egui, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported. Use --native-backend rust for external modules.".to_string(),
                 });
             }
 
@@ -132,7 +136,7 @@ pub fn compile_to_native(
             };
             if tishlang_compile::has_external_native_imports(&program) {
                 return Err(NativeError {
-                    message: "LLVM backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
             let chunk = if optimize {
@@ -180,6 +184,8 @@ pub fn compile_program_to_native(
             let root = project_root.unwrap_or_else(|| Path::new("."));
             let native_modules = tishlang_compile::resolve_native_modules(&program, root)
                 .map_err(|e| NativeError { message: e })?;
+            let native_build = tishlang_compile::compute_native_build_artifacts(&program, root, &native_modules)
+                .map_err(|e| NativeError { message: e })?;
             let mut all_features = features.to_vec();
             for f in tishlang_compile::extract_native_import_features(&program) {
                 if !all_features.contains(&f) {
@@ -191,18 +197,27 @@ pub fn compile_program_to_native(
                 project_root,
                 &all_features,
                 &native_modules,
+                &native_build.native_init,
                 optimize,
             )
             .map_err(|e| NativeError {
                 message: e.message,
             })?;
-            crate::build::build_via_cargo(&rust_code, native_modules, output_path, &all_features)
-                .map_err(|e| NativeError { message: e })
+            crate::build::build_via_cargo(
+                &rust_code,
+                native_modules,
+                output_path,
+                &all_features,
+                &native_build.rust_dependencies_toml,
+                native_build.generated_native_rs.as_deref(),
+                Some(root),
+            )
+            .map_err(|e| NativeError { message: e })
         }
         Backend::Cranelift => {
             if tishlang_compile::has_external_native_imports(program) {
                 return Err(NativeError {
-                    message: "Cranelift backend does not support external native imports. Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
+                    message: "Cranelift backend does not support external native imports (tish:…, cargo:…, @scope/pkg). Built-in tish:fs, tish:http, tish:process are supported.".to_string(),
                 });
             }
             let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };
@@ -218,7 +233,7 @@ pub fn compile_program_to_native(
         Backend::Llvm => {
             if tishlang_compile::has_external_native_imports(program) {
                 return Err(NativeError {
-                    message: "LLVM backend does not support external native imports.".to_string(),
+                    message: "LLVM backend does not support external native imports (tish:…, cargo:…, @scope/pkg).".to_string(),
                 });
             }
             let program = if optimize { tishlang_opt::optimize(program) } else { program.clone() };

package/crates/tish_vm/src/vm.rs

@@ -1260,10 +1260,17 @@ impl Vm {
                         }
                     };
                     let v = get_builtin_export(self.capabilities.as_ref(), spec, export_name).ok_or_else(|| {
-                        format!(
-                            "Built-in module '{}' does not export '{}' or capability not enabled for this run. Use e.g. tish run --feature fs (or full). The tish binary must also be built with that capability linked in.",
-                            spec, export_name
-                        )
+                        if spec.starts_with("cargo:") {
+                            format!(
+                                "cargo:… imports are only supported by `tish build` with the Rust native backend (not the bytecode VM). Spec: {}",
+                                spec
+                            )
+                        } else {
+                            format!(
+                                "Built-in module '{}' does not export '{}' or capability not enabled for this run. Use e.g. tish run --feature fs (or full). The tish binary must also be built with that capability linked in.",
+                                spec, export_name
+                            )
+                        }
                     })?;
                     self.stack.push(v);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {