@tishlang/tish-lint 3.1.0 → 3.2.2

package/crates/tish/src/cli_help.rs

@@ -404,6 +404,10 @@ pub fn build_after_help() -> String {
           Native executable (see --native-backend)
   {t}js{r}
           JavaScript bundle
+  {t}rust-lib{r}
+          Rust library source crate (crate-type = \"rlib\") at `-o <dir>` — one `pub fn` per
+          `export fn` of the entry module, over `tishlang_runtime::Value`. Cargo is NOT run; the
+          crate is the output, for the consumer to depend on. The Rust counterpart of `--target js`
   {t}wasm{r}
           WebAssembly (.tish project; .js source supported on some paths)
   {t}wasm-gpu{r}

package/crates/tish/src/main.rs

@@ -914,9 +914,9 @@ fn build_file(
         .map_err(|e| e.to_string());
     }
 
-    if target != "native" && target != "gba" {
+    if target != "native" && target != "gba" && target != "rust-lib" {
         return Err(format!(
-            "Unknown target: {}. Use 'native', 'gba', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
+            "Unknown target: {}. Use 'native', 'gba', 'rust-lib', 'js', 'wasm', 'wasm-gpu', 'wasi', or 'bytecode'.",
             target
         ));
     }
@@ -935,6 +935,11 @@ fn build_file(
             return Err("tish build --target gba requires a .tish entry file.".to_string());
         }
         tishlang_native::NativeBuildConfig::gba()
+    } else if target == "rust-lib" {
+        if is_js {
+            return Err("tish build --target rust-lib requires a .tish entry file.".to_string());
+        }
+        tishlang_native::NativeBuildConfig::rust_lib()
     } else if let Some(triple) = ios_triple {
         tishlang_native::NativeBuildConfig::ios_staticlib(triple)
     } else if crate_type == "staticlib" {
@@ -982,6 +987,12 @@ fn build_file(
         .map_err(|e| e.to_string())?;
     }
 
+    // `rust-lib` writes a crate DIRECTORY at `-o`, and already reported it — the artifact-path
+    // rewriting below is all about locating a single built file, which does not apply.
+    if build_config.artifact == tishlang_native::NativeArtifact::RustLib {
+        return Ok(());
+    }
+
     let out_name = Path::new(output_path)
         .file_stem()
         .and_then(|s| s.to_str())

package/crates/tish/tests/rust_lib_crate.rs

@@ -0,0 +1,140 @@
+//! `tish build --target rust-lib` end to end: the emitted artifact is a Cargo **source crate**, and
+//! cargo is deliberately not run — the consumer decides what to build it for.
+//!
+//! The fast test pins the crate layout. The behavioural test — module state surviving between
+//! `pub fn` calls, a `clear*()` reassignment being visible to other exports, and the module body
+//! running exactly once — actually builds the crate and a consumer, so it is gated behind
+//! `TISH_SLOW_TESTS=1` to keep the default `cargo test` fast.
+use std::path::{Path, PathBuf};
+
+fn fixture() -> PathBuf {
+    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../tests/regression/rust_lib_emit.tish")
+        .canonicalize()
+        .unwrap()
+}
+
+fn emit_crate(out: &Path) {
+    let entry = fixture();
+    tishlang_native::compile_to_native_with_config(
+        &entry,
+        entry.parent(),
+        out,
+        &[],
+        "rust",
+        true,
+        &tishlang_native::NativeBuildConfig::rust_lib(),
+    )
+    .expect("rust-lib emit");
+}
+
+#[test]
+fn emits_an_rlib_source_crate_and_does_not_run_cargo() {
+    let out = std::env::temp_dir().join("tish_rustlib_layout");
+    let _ = std::fs::remove_dir_all(&out);
+    emit_crate(&out);
+
+    let manifest = std::fs::read_to_string(out.join("Cargo.toml")).expect("Cargo.toml");
+    assert!(
+        manifest.contains(r#"crate-type = ["rlib"]"#),
+        "expected an rlib library crate:\n{manifest}"
+    );
+    assert!(
+        manifest.contains("path = \"src/lib.rs\""),
+        "expected a lib entry point:\n{manifest}"
+    );
+    // Both `path` and `version` on the runtime dep: cargo prefers the path locally and falls back to
+    // the registry when the emitted crate is published, so it is publishable as-is.
+    assert!(
+        manifest.contains("tishlang_runtime = { path =") && manifest.contains("version = \""),
+        "the runtime dep must carry both path and version:\n{manifest}"
+    );
+
+    assert!(out.join("src/lib.rs").is_file(), "expected src/lib.rs");
+    assert!(
+        !out.join("src/main.rs").exists(),
+        "a library crate must not emit src/main.rs"
+    );
+    // Cargo was not invoked: no build output next to the emitted crate.
+    assert!(
+        !out.join("target").exists(),
+        "--target rust-lib must emit the crate and stop, not build it"
+    );
+}
+
+/// `TISH_SLOW_TESTS=1 cargo test -p tishlang --test rust_lib_crate` — compiles the emitted crate
+/// plus a consumer that exercises the module-state guarantees.
+#[test]
+fn consumer_observes_persistent_module_state() {
+    if std::env::var("TISH_SLOW_TESTS").as_deref() != Ok("1") {
+        eprintln!("skipped (set TISH_SLOW_TESTS=1 to run the full cargo build)");
+        return;
+    }
+    let root = std::env::temp_dir().join("tish_rustlib_e2e");
+    let _ = std::fs::remove_dir_all(&root);
+    let lib = root.join("lib");
+    emit_crate(&lib);
+
+    let consumer = root.join("consumer");
+    std::fs::create_dir_all(consumer.join("src")).unwrap();
+    std::fs::write(
+        consumer.join("Cargo.toml"),
+        format!(
+            "[package]\nname = \"consumer\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n\
+             [workspace]\n\n[dependencies]\nlib = {{ package = \"lib\", path = {:?} }}\n",
+            lib.display().to_string()
+        ),
+    )
+    .unwrap();
+    std::fs::write(
+        consumer.join("src/main.rs"),
+        r#"
+use lib::Value;
+fn num(v: &Value) -> f64 { match v { Value::Number(x) => *x, _ => f64::NAN } }
+fn text(v: &Value) -> String { match v { Value::String(x) => x.to_string(), _ => String::new() } }
+fn main() {
+    // First call is not the first declared export: init must already have run.
+    assert_eq!(num(&lib::add(Value::Number(2.0), Value::Number(40.0))), 42.0, "add");
+    assert_eq!(num(&lib::initRuns()), 1.0, "module top level runs once");
+
+    lib::register(Value::String("kick".into()), Value::String("noiseBurst".into()));
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "noiseBurst", "state persists");
+
+    // `clearAll` REASSIGNS the module-level binding; other exports must see that.
+    assert_eq!(num(&lib::clearAll()), 0.0, "clearAll empties");
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "miss", "reassignment visible");
+
+    assert_eq!(num(&lib::initRuns()), 1.0, "still initialised once");
+
+    // A throw is parked for the next checkpoint, not unwound. Across the `pub fn` boundary there is
+    // no Tish frame to surface it in, so a parked throw used to sit latched and make every LATER
+    // call bail and return null. Reading a property off a null is all it takes.
+    let _ = lib::runtime::get_index(&Value::Null, &Value::String("nope".into()));
+    assert_eq!(
+        num(&lib::add(Value::Number(1.0), Value::Number(2.0))),
+        3.0,
+        "a parked throw must not brick the module"
+    );
+    for _ in 0..20 {
+        let _ = lib::runtime::get_index(&Value::Null, &Value::String("nope".into()));
+    }
+    assert_eq!(text(&lib::lookup(Value::String("kick".into()))), "miss", "still working after 20");
+
+    println!("ALL_OK");
+}
+"#,
+    )
+    .unwrap();
+
+    let out = std::process::Command::new("cargo")
+        .args(["run", "-q"])
+        .current_dir(&consumer)
+        .output()
+        .expect("cargo run");
+    assert!(
+        String::from_utf8_lossy(&out.stdout).contains("ALL_OK"),
+        "consumer failed:\nstdout: {}\nstderr: {}",
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+}

package/crates/tish_compile/src/codegen.rs

@@ -652,7 +652,7 @@ pub fn compile_project_full_emit(
     if let Some(cap) = feature_cap {
         all_features.retain(|f| cap.contains(f));
     }
-    let rust = compile_with_native_modules_emit(
+    let rust = compile_with_native_modules_emit_exports(
         &merged.program,
         project_root,
         &all_features,
@@ -660,6 +660,7 @@ pub fn compile_project_full_emit(
         &native_build.native_init,
         optimize,
         emit_mode,
+        &merged.entry_exports,
     )?;
     Ok((rust, native_modules, all_features, native_build))
 }
@@ -728,6 +729,16 @@ fn run_type_check(program: &Program) -> Result<(), CompileError> {
     Ok(())
 }
 
+/// One entry-module export, as the `RustLib` surface sees it.
+struct RustLibExport {
+    /// The Rust local `run()` binds — for a re-export, the dependency's binding.
+    local_name: String,
+    /// The name the crate exposes (and the key in the export table).
+    exported_name: String,
+    /// Parameter count when the export names a `fn`; `None` for a value export.
+    arity: Option<usize>,
+}
+
 pub fn compile_with_native_modules_emit(
     program: &Program,
     project_root: Option<&Path>,
@@ -736,6 +747,33 @@ pub fn compile_with_native_modules_emit(
     native_init: &std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
     optimize: bool,
     emit_mode: crate::NativeEmitMode,
+) -> Result<String, CompileError> {
+    compile_with_native_modules_emit_exports(
+        program,
+        project_root,
+        features,
+        native_modules,
+        native_init,
+        optimize,
+        emit_mode,
+        &[],
+    )
+}
+
+/// Like [`compile_with_native_modules_emit`], plus the entry module's exported
+/// `(local_name, exported_name)` pairs. Only [`crate::NativeEmitMode::RustLib`] reads them — they
+/// become the emitted crate's `pub fn` surface. Every other mode ignores the argument, which is
+/// why the plain entry point above can pass `&[]`.
+#[allow(clippy::too_many_arguments)]
+pub fn compile_with_native_modules_emit_exports(
+    program: &Program,
+    project_root: Option<&Path>,
+    features: &[String],
+    native_modules: &[crate::resolve::ResolvedNativeModule],
+    native_init: &std::collections::HashMap<String, crate::resolve::NativeModuleInit>,
+    optimize: bool,
+    emit_mode: crate::NativeEmitMode,
+    entry_exports: &[(String, String)],
 ) -> Result<String, CompileError> {
     // Per-compile thread-local state — the narrow-int/`fixed`/`i32` numeric profile and the import-
     // scheme registry — must not outlive THIS compile. Both persist on the thread, so a later compile
@@ -786,6 +824,7 @@ pub fn compile_with_native_modules_emit(
         };
     let mut g = Codegen::new_with_native_modules(project_root, features, map);
     g.emit_mode = emit_mode;
+    g.entry_exports = entry_exports.to_vec();
     g.has_native_ui_host = native_modules.iter().any(|m| {
         m.package_name == "tish-macos"
             || m.package_name == "tish-ios"
@@ -1245,6 +1284,10 @@ pub(crate) struct Codegen {
     /// closures it must not return a `Result` from a `Value`-returning closure.
     value_fn_depth: u32,
     emit_mode: crate::NativeEmitMode,
+    /// `RustLib` only: the entry module's `(local_name, exported_name)` pairs, as computed by
+    /// `merge_modules` for the JS bundle's trailing `export { … }`. Drives the `pub fn` wrappers.
+    /// Empty for every other emit mode.
+    entry_exports: Vec<(String, String)>,
     /// Scheme imports as `(scheme_name, absolute_path)`, in first-seen order. Populated (Gba mode)
     /// before the entry is emitted from the active [`crate::schemes`] registry; drives the
     /// `mod __scheme_<name>_<j> { … }` blocks and their per-scheme registration. The handle a tish
@@ -1363,6 +1406,7 @@ impl Codegen {
             program_fun_decl_names: std::collections::HashSet::new(),
             value_fn_depth: 0,
             emit_mode: crate::NativeEmitMode::DesktopBin,
+            entry_exports: Vec::new(),
             scheme_files: Vec::new(),
             has_native_ui_host: false,
             program_uses_document: false,
@@ -2939,6 +2983,14 @@ impl Codegen {
             self.write("use std::rc::Rc;\n");
             self.write("use std::sync::Arc;\n");
         }
+        // RustLib: re-export the runtime prelude rather than importing it privately, so the crate's
+        // public API is self-contained — a consumer gets `Value` (and `ObjectMap` / `PropMap` /
+        // `VmRef`) from THIS crate and cannot version-skew them against a separate `tishlang_runtime`
+        // dependency of their own. Also avoids a duplicate-import error, since `Value` is already in
+        // this list and could not be re-exported a second time at the crate root.
+        if self.emit_mode == crate::NativeEmitMode::RustLib {
+            self.write("pub ");
+        }
         self.write("use tishlang_runtime::{console_debug as tish_console_debug, console_info as tish_console_info, console_log as tish_console_log, console_warn as tish_console_warn, console_error as tish_console_error, boolean as tish_boolean, decode_uri as tish_decode_uri, encode_uri as tish_encode_uri, encode_uri_component as tish_encode_uri_component, decode_uri_component as tish_decode_uri_component, string_escape_html_impl as tish_escape_html, in_operator as tish_in_operator, is_finite as tish_is_finite, is_nan as tish_is_nan, json_parse as tish_json_parse, json_stringify as tish_json_stringify, math_abs as tish_math_abs, math_ceil as tish_math_ceil, math_floor as tish_math_floor, math_max as tish_math_max, math_min as tish_math_min, math_round as tish_math_round, math_sqrt as tish_math_sqrt, parse_float as tish_parse_float, parse_int as tish_parse_int, math_random as tish_math_random, math_pow as tish_math_pow, math_sin as tish_math_sin, math_cos as tish_math_cos, math_tan as tish_math_tan, math_log as tish_math_log, math_exp as tish_math_exp, math_sign as tish_math_sign, math_trunc as tish_math_trunc, math_imul as tish_math_imul, math_sinh as tish_math_sinh, math_cosh as tish_math_cosh, math_tanh as tish_math_tanh, math_asinh as tish_math_asinh, math_acosh as tish_math_acosh, math_atanh as tish_math_atanh, math_cbrt as tish_math_cbrt, math_log2 as tish_math_log2, math_log10 as tish_math_log10, math_expm1 as tish_math_expm1, math_log1p as tish_math_log1p, math_clz32 as tish_math_clz32, math_fround as tish_math_fround, math_hypot as tish_math_hypot, math_atan2 as tish_math_atan2, math_asin as tish_math_asin, math_acos as tish_math_acos, math_atan as tish_math_atan, array_is_array as tish_array_is_array, array_of as tish_array_of, array_from as tish_array_from, object_is as tish_object_is, object_has_own as tish_object_has_own, structured_clone as tish_structured_clone, array_construct as tish_array_construct, string_from_char_code as tish_string_from_char_code, string_convert as tish_string_convert, number_convert as tish_number_convert, number_is_integer as tish_number_is_integer, number_is_safe_integer as tish_number_is_safe_integer, number_is_nan as tish_number_is_nan, number_is_finite as tish_number_is_finite, object_assign as tish_object_assign, object_freeze as tish_object_freeze, object_is_frozen as tish_object_is_frozen, object_keys as tish_object_keys, object_values as tish_object_values, object_entries as tish_object_entries, object_from_entries as tish_object_from_entries, symbol_object as tish_symbol_object, tish_construct, tish_error_constructor, tish_date_constructor, tish_set_constructor, tish_map_constructor, map_get as tish_map_get, map_has as tish_map_has, map_set as tish_map_set, map_values as tish_map_values, tish_float64_array_constructor, tish_float32_array_constructor, tish_int8_array_constructor, tish_uint8_array_constructor, tish_uint8_clamped_array_constructor, tish_int16_array_constructor, tish_uint16_array_constructor, tish_int32_array_constructor, tish_uint32_array_constructor, tish_audio_context_constructor, ObjectMap, ObjectData, PropMap, TishError, Value, VmRef};\n");
         if self.program_has_jsx {
             self.write("use tishlang_ui::{fragment_value, install_thread_local_host, native_create_root, native_use_state, ui_h, ui_text, HeadlessHost};\n");
@@ -3054,6 +3106,9 @@ impl Codegen {
             self.writeln("}");
             self.writeln("");
         }
+        if self.emit_mode == crate::NativeEmitMode::RustLib {
+            self.emit_rust_lib_surface(program)?;
+        }
         // M5 (default-on via native_opts_enabled; TISH_NATIVE_OPT=0 opts out): emit a parallel
         // native `fn f_native` for each eligible top-level numeric fn at top level; direct calls
         // route to it in emit_typed_expr.
@@ -3552,6 +3607,29 @@ impl Codegen {
             self.writeln("tishlang_runtime::drain_timers();");
         }
 
+        // RustLib: hand the entry module's exported bindings to the thread-local table before
+        // `run()`'s frame drops. The bindings are ordinary `Value` locals; cloning one clones an
+        // `Rc`, so the closure — and every module-level cell it captured — stays alive and shared.
+        // That is what makes module state survive between `pub fn` calls (and stay mutable through
+        // `clear*`-style reassignment, since captures are `VmRef` cells, not copies).
+        if self.emit_mode == crate::NativeEmitMode::RustLib {
+            let pairs: Vec<String> = self
+                .rust_lib_exports(program)
+                .iter()
+                .map(|e| {
+                    format!(
+                        "({:?}, {}.clone())",
+                        e.exported_name,
+                        Self::escape_ident(&e.local_name)
+                    )
+                })
+                .collect();
+            self.writeln(&format!(
+                "__tish_publish_exports(::std::vec![{}]);",
+                pairs.join(", ")
+            ));
+        }
+
         self.writeln("Ok(())");
         self.indent -= 1;
         self.writeln("}");
@@ -3580,6 +3658,191 @@ impl Codegen {
         Ok(())
     }
 
+    /// The entry module's exports, paired with the arity of the `fn` each names (if it names one).
+    /// `merge_modules` unwraps `export` into plain top-level declarations and records the
+    /// `(local, exported)` pairs — including through `export { … } from './x.tish'` re-exports,
+    /// which resolve to the dependency's local binding — so a barrel module still yields the full
+    /// surface. Sorted for deterministic output.
+    fn rust_lib_exports(&self, program: &Program) -> Vec<RustLibExport> {
+        let mut arities: std::collections::HashMap<&str, usize> =
+            std::collections::HashMap::new();
+        for stmt in &program.statements {
+            if let Statement::FunDecl { name, params, .. } = stmt {
+                arities.insert(name.as_ref(), params.len());
+            }
+        }
+        let mut out: Vec<RustLibExport> = self
+            .entry_exports
+            .iter()
+            .map(|(local, exported)| RustLibExport {
+                local_name: local.clone(),
+                exported_name: exported.clone(),
+                arity: arities.get(local.as_str()).copied(),
+            })
+            .collect();
+        out.sort_by(|a, b| a.exported_name.cmp(&b.exported_name));
+        out
+    }
+
+    /// Emit the `RustLib` public surface: the thread-local module instance, the lazy `ensure_init`,
+    /// and one `pub fn` per entry export.
+    ///
+    /// The module body itself is the ordinary `run()` — this only changes *when* it runs and what
+    /// outlives it. Storage is `thread_local!` rather than a global because `Value` is `!Send`
+    /// unless the `send-values` feature is on (it follows `http`), so a `static` would not compile
+    /// for the common configuration. Per-thread instances also match how a consumer uses this:
+    /// register into the module's registries, then call it, on one thread.
+    fn emit_rust_lib_surface(&mut self, program: &Program) -> Result<(), CompileError> {
+        if self.is_async {
+            return Err(CompileError::new(
+                "--target rust --emit lib: the entry module has top-level `await`. A library has \
+                 no runtime to drive it — move the async work into an exported function."
+                    .to_string(),
+                None,
+            ));
+        }
+        let exports = self.rust_lib_exports(program);
+        if exports.is_empty() {
+            return Err(CompileError::new(
+                "--target rust --emit lib: the entry module exports nothing, so the crate would \
+                 have no public API. Add `export fn …` to the entry module."
+                    .to_string(),
+                None,
+            ));
+        }
+        // Only `export fn` is supported. A value export has no arity, and its Rust local is not
+        // necessarily a `Value` to publish (a `const` string lowers to `&str`), so it cannot be
+        // handed to the export table the way a closure can. Say so instead of emitting a getter
+        // that would always read back null.
+        let non_fn: Vec<&str> = exports
+            .iter()
+            .filter(|e| e.arity.is_none())
+            .map(|e| e.exported_name.as_str())
+            .collect();
+        if !non_fn.is_empty() {
+            return Err(CompileError::new(
+                format!(
+                    "--target rust --emit lib: only `export fn` can cross the crate boundary, but \
+                     the entry module also exports the value(s) `{}`. Wrap each in an exported \
+                     function (`export fn {}() {{ … }}`).",
+                    non_fn.join("`, `"),
+                    non_fn[0]
+                ),
+                None,
+            ));
+        }
+
+        self.writeln("// ── Tish library surface ──────────────────────────────────────────────");
+        // `Value` and friends are already re-exported by the (pub) runtime prelude above; this adds
+        // the whole runtime for consumers that need more than the prelude carries.
+        self.writeln("pub use tishlang_runtime as runtime;");
+        self.writeln("");
+        self.writeln("thread_local! {");
+        self.indent += 1;
+        self.writeln(
+            "static __TISH_MODULE: ::std::cell::RefCell<::std::option::Option<::std::collections::HashMap<&'static str, Value>>> =",
+        );
+        self.writeln("    ::std::cell::RefCell::new(::std::option::Option::None);");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("/// Called once from the tail of `run()` with the entry module's exports.");
+        self.writeln("fn __tish_publish_exports(pairs: ::std::vec::Vec<(&'static str, Value)>) {");
+        self.indent += 1;
+        self.writeln("__TISH_MODULE.with(|m| {");
+        self.writeln("    *m.borrow_mut() = ::std::option::Option::Some(pairs.into_iter().collect());");
+        self.writeln("});");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("/// Run the module body exactly once per thread, before the first export call.");
+        self.writeln("fn __tish_ensure_init() {");
+        self.indent += 1;
+        self.writeln("// Park an empty table BEFORE running the body: that makes init non-reentrant");
+        self.writeln("// (an export reached while the module is still initialising sees an empty");
+        self.writeln("// table and returns null, rather than recursing forever).");
+        self.writeln("let fresh = __TISH_MODULE.with(|m| {");
+        self.writeln("    let mut b = m.borrow_mut();");
+        self.writeln("    if b.is_some() { return false; }");
+        self.writeln("    *b = ::std::option::Option::Some(::std::collections::HashMap::new());");
+        self.writeln("    true");
+        self.writeln("});");
+        self.writeln("if fresh {");
+        self.writeln("    // A module whose top level fails cannot be recovered from here: every");
+        self.writeln("    // export would observe half-initialised state.");
+        self.writeln("    run().unwrap_or_else(|e| panic!(\"tish module initialisation failed: {}\", e));");
+        self.writeln("}");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("/// Clone an export out of the table. The borrow is released before the value is");
+        self.writeln("/// used, because an export is free to call back into another export.");
+        self.writeln("fn __tish_export(name: &str) -> Value {");
+        self.indent += 1;
+        self.writeln("__tish_ensure_init();");
+        self.writeln("__TISH_MODULE.with(|m| {");
+        self.writeln("    m.borrow().as_ref().and_then(|t| t.get(name).cloned()).unwrap_or(Value::Null)");
+        self.writeln("})");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("thread_local! {");
+        self.writeln("    static __TISH_LAST_THROW: ::std::cell::RefCell<Value> = ::std::cell::RefCell::new(Value::Null);");
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("/// The value thrown by the most recent export call, or null if it completed normally.");
+        self.writeln("///");
+        self.writeln("/// A `pub fn … -> Value` has no error channel, so a throw that escapes an export is drained");
+        self.writeln("/// and recorded here rather than left parked. Reading it is the way to tell \"returned null\"");
+        self.writeln("/// from \"threw\".");
+        self.writeln("pub fn tish_last_throw() -> Value {");
+        self.indent += 1;
+        self.writeln("__TISH_LAST_THROW.with(|t| t.borrow().clone())");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+        self.writeln("fn __tish_call_export(name: &str, args: &[Value]) -> Value {");
+        self.indent += 1;
+        self.writeln("// A throw is PARKED for the next checkpoint rather than unwound (#303). Across a `pub fn`");
+        self.writeln("// boundary there is no Tish frame to surface it in, so a parked throw would sit latched and");
+        self.writeln("// every LATER call would bail at its own checkpoint and silently return null — one bad call");
+        self.writeln("// bricking the module for the rest of the process. A host hits this simply by reading a");
+        self.writeln("// property off a null the runtime handed it. So: enter clean, leave clean.");
+        self.writeln("let _ = tishlang_runtime::take_pending_throw();");
+        self.writeln("let out = match __tish_export(name) {");
+        self.writeln("    Value::Function(f) => f.call(args),");
+        self.writeln("    other => other,");
+        self.writeln("};");
+        self.writeln("let thrown = tishlang_runtime::take_pending_throw().unwrap_or(Value::Null);");
+        self.writeln("__TISH_LAST_THROW.with(|t| *t.borrow_mut() = thrown);");
+        self.writeln("out");
+        self.indent -= 1;
+        self.writeln("}");
+        self.writeln("");
+
+        for e in &exports {
+            // Checked above: every remaining export is a `fn`, so the arity is present.
+            let n = e.arity.unwrap_or(0);
+            let params: Vec<String> = (0..n).map(|i| format!("a{}: Value", i)).collect();
+            let args: Vec<String> = (0..n).map(|i| format!("a{}", i)).collect();
+            self.writeln(&format!(
+                "pub fn {}({}) -> Value {{",
+                Self::escape_ident(&e.exported_name),
+                params.join(", ")
+            ));
+            self.indent += 1;
+            self.writeln(&format!(
+                "__tish_call_export({:?}, &[{}])",
+                e.exported_name,
+                args.join(", ")
+            ));
+            self.indent -= 1;
+            self.writeln("}");
+        }
+        self.writeln("");
+        Ok(())
+    }
+
     /// Emit an expression in **statement position** (its value is discarded). For a native
     /// assignment this emits only the side-effect — NOT the boxed `Value::Number(..)` that the
     /// expression form returns (JS "assignment yields its value"). In a hot loop that boxed
@@ -6963,6 +7226,23 @@ impl Codegen {
         Ok(())
     }
 
+    /// `.clone()` an emitted operand that is a bare Rust identifier, leave anything else alone.
+    ///
+    /// Used where an operand is yielded as the value of an expression that does not consume it
+    /// exclusively (`&&` / `||`): moving a non-`Copy` `Value` local out of such a position makes
+    /// every later read a use-after-move. A parenthesised expression, call, field access, or an
+    /// already-`.clone()`d ident is a temporary, so it needs nothing.
+    fn clone_if_bare_ident(s: &str) -> String {
+        let bare = !s.is_empty()
+            && !s.starts_with(|c: char| c.is_ascii_digit())
+            && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '_');
+        if bare {
+            format!("{}.clone()", s)
+        } else {
+            s.to_string()
+        }
+    }
+
     fn emit_call_arg(&mut self, arg: &CallArg) -> Result<String, CompileError> {
         let e = match arg {
             CallArg::Expr(e) | CallArg::Spread(e) => e,
@@ -21944,6 +22224,14 @@ impl Codegen {
     /// the routing state so call sites de-virtualize. On any failure the state is left empty (path
     /// disabled) and nothing is appended to the output.
     fn setup_aggregate_fns(&mut self, program: &Program) {
+        // #177 de-virtualization deletes the boxed `let <name> = Value::native(..)` local for every
+        // routed fn. `RustLib` publishes exactly those locals as the crate's public API, so an
+        // exported fn that got de-virtualized would leave the emitted `__tish_publish_exports` call
+        // referencing a binding that no longer exists. The unboxed path is a numeric fast path;
+        // a correct public surface outranks it.
+        if self.emit_mode == crate::NativeEmitMode::RustLib {
+            return;
+        }
         let dbg = std::env::var("TISH_AGG_DEBUG").is_ok();
         // The unboxed struct alias: the (unique) name `A` used as an `A[]` array param of some fn,
         // and registered as an all-`Copy`-field struct alias.
@@ -25014,8 +25302,21 @@ impl Codegen {
             // the same local (`aid && out.indexOf(aid)`), and a bare `let __l = aid;` moves the non-`Copy`
             // `Value` so the reuse is a borrow-after-move (E0382). The left operand is still evaluated
             // exactly once (its side effects don't double-run); only its value is cloned for the test.
-            BinOp::And => format!("{{ let __l = ({}).clone(); if __l.is_truthy() {{ {} }} else {{ __l }} }}", l, r),
-            BinOp::Or => format!("{{ let __l = ({}).clone(); if __l.is_truthy() {{ __l }} else {{ {} }} }}", l, r),
+            //
+            // The RESULT operand has the same hazard: when it lowers to a bare local (`inGenBlock &&
+            // currentTrack`), yielding it moves that local out, so a later read — the next iteration
+            // of the enclosing loop, or any subsequent use — is E0382. Clone it in that case only;
+            // anything else is already a temporary (or already cloned), so the fast path is unchanged.
+            BinOp::And => format!(
+                "{{ let __l = ({}).clone(); if __l.is_truthy() {{ {} }} else {{ __l }} }}",
+                l,
+                Self::clone_if_bare_ident(r)
+            ),
+            BinOp::Or => format!(
+                "{{ let __l = ({}).clone(); if __l.is_truthy() {{ __l }} else {{ {} }} }}",
+                l,
+                Self::clone_if_bare_ident(r)
+            ),
             BinOp::BitAnd => Self::emit_bitwise_binop(l, r, "&"),
             BinOp::BitOr => Self::emit_bitwise_binop(l, r, "|"),
             BinOp::BitXor => Self::emit_bitwise_binop(l, r, "^"),

package/crates/tish_compile/src/lib.rs

@@ -40,6 +40,19 @@ pub enum NativeEmitMode {
     DesktopBin,
     /// `[lib] crate-type = ["staticlib"]` — no `fn main()`, host calls `tish_ios_launch`.
     EmbeddedLib,
+    /// `[lib] crate-type = ["rlib"]` — a Rust *library* crate whose public API is the entry
+    /// module's `export fn`s, so a Tish library can be consumed from Rust the way `--target js`
+    /// lets it be consumed from JS. No `fn main()`, no `tish_ios_launch`.
+    ///
+    /// The module body still lowers to the ordinary whole-program `run()`; what differs is that
+    /// `run()` is invoked lazily behind an `ensure_init()` and its exported bindings are parked in
+    /// a `thread_local!` so they outlive the call. That keeps module-level state alive between
+    /// `pub fn` calls with the same semantics an ESM module has — including reassignment, since
+    /// top-level `let`s are captured by the emitted closures as `VmRef` cells.
+    ///
+    /// `thread_local!` (rather than a global) is forced by `Value`: `send-values` is off unless
+    /// `http` is enabled, so `VmRef` is `Rc<RefCell<_>>` and `Value` is `!Send`.
+    RustLib,
     /// Game Boy Advance ROM: `#![no_std]`, `#[agb::entry] fn agb_main(gba)`, links the
     /// `tishlang_runtime_gba` facade. Numbers/async lowering diverge; see codegen `emit_program`.
     Gba,
@@ -49,7 +62,7 @@ pub use codegen::CompileError;
 pub use codegen::{
     compile, compile_project, compile_project_full, compile_project_full_emit,
     compile_with_features, compile_with_native_modules, compile_with_native_modules_emit,
-    compile_with_project_root,
+    compile_with_native_modules_emit_exports, compile_with_project_root,
 };
 pub use platform_resolve::{
     apply_resolve_env, parse_platform, parse_surface, platform_suffixes, platform_virtual_keys,

package/crates/tish_compile/tests/regr_andor_rhs_move.rs

@@ -0,0 +1,85 @@
+//! Regression: `&&` / `||` yield the deciding OPERAND (JS semantics, #240). #328 fixed the left
+//! operand to bind by `.clone()` rather than by move; the right operand had the identical hazard.
+//!
+//! When the right operand lowers to a bare local — `inGenBlock && currentTrack` — yielding it moved
+//! that local out of scope, so any later read was `E0382: use of moved value`. It only bites when
+//! the operand is a plain non-`Copy` `Value` local that is read again (typically the next iteration
+//! of the enclosing loop), which is why it survived: the common right operand is a call or an
+//! already-cloned expression, which are temporaries.
+//!
+//! Found compiling `@spacedevin/deck`'s `Parser.tish`, whose statement loop does exactly this. The
+//! source runs fine under `--target js` and the interpreter, so the divergence was Rust-backend-only.
+use tishlang_compile::compile;
+use tishlang_parser::parse;
+
+fn rust_for(src: &str) -> String {
+    compile(&parse(src).unwrap()).unwrap()
+}
+
+#[test]
+fn bare_ident_right_operand_is_cloned_not_moved() {
+    let rust = rust_for(
+        r#"
+fn f() {
+  let cur = null
+  let flag = true
+  let i = 0
+  while (i < 3) {
+    if (flag && cur) { return 1 }
+    if (flag && cur) { return 2 }
+    i = i + 1
+  }
+  return 0
+}
+"#,
+    );
+    assert!(
+        rust.contains("if __l.is_truthy() { cur.clone() }"),
+        "a bare-ident right operand must be cloned out, not moved:\n{rust}"
+    );
+    assert!(
+        !rust.contains("if __l.is_truthy() { cur }"),
+        "found the moving form, which is E0382 on the second read:\n{rust}"
+    );
+}
+
+#[test]
+fn or_right_operand_gets_the_same_treatment() {
+    let rust = rust_for(
+        r#"
+fn f() {
+  let a = null
+  let b = null
+  let i = 0
+  while (i < 3) {
+    let x = a || b
+    let y = a || b
+    i = i + 1
+  }
+  return 0
+}
+"#,
+    );
+    assert!(
+        rust.contains("else { b.clone() }"),
+        "`||` must clone a bare-ident right operand too:\n{rust}"
+    );
+}
+
+#[test]
+fn non_ident_right_operands_are_not_given_a_redundant_clone() {
+    // A call result is already a temporary — cloning it would be pure overhead on a hot path.
+    let rust = rust_for(
+        r#"
+fn g() { return 1 }
+fn f() {
+  let flag = true
+  return flag && g()
+}
+"#,
+    );
+    assert!(
+        !rust.contains("))).clone().clone()"),
+        "an already-temporary right operand must not gain a second clone:\n{rust}"
+    );
+}

package/crates/tish_compile/tests/regr_rust_lib_emit.rs

@@ -0,0 +1,150 @@
+//! `--target rust-lib` (`NativeEmitMode::RustLib`): a Tish library compiled to a Rust library crate
+//! whose public API is the entry module's `export fn`s — the Rust counterpart of `--target js`.
+//!
+//! The module body still lowers to the ordinary whole-program `run()`. What the library emit adds is
+//! (a) one `pub fn` per export and (b) keeping the exported bindings alive past `run()` in a
+//! thread-local, so module-level state survives between calls. These tests pin that emitted shape;
+//! the crate layout and the behavioural end (state persists, reassignment is observable, init runs
+//! once) are covered in `crates/tish/tests/rust_lib_crate.rs`.
+use std::path::PathBuf;
+use tishlang_compile::{compile_project_full, compile_project_full_emit, NativeEmitMode};
+
+fn fixture(rel: &str) -> PathBuf {
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    manifest.join("../..").join(rel).canonicalize().unwrap()
+}
+
+fn compile_lib(rel: &str) -> String {
+    let path = fixture(rel);
+    compile_project_full_emit(&path, path.parent(), &[], true, NativeEmitMode::RustLib, None)
+        .expect("rust-lib emit")
+        .0
+}
+
+#[test]
+fn every_export_becomes_an_arity_matched_pub_fn() {
+    let rust = compile_lib("tests/regression/rust_lib_emit.tish");
+    for sig in [
+        "pub fn register(a0: Value, a1: Value) -> Value",
+        "pub fn lookup(a0: Value) -> Value",
+        "pub fn clearAll() -> Value",
+        "pub fn initRuns() -> Value",
+        "pub fn add(a0: Value, a1: Value) -> Value",
+    ] {
+        assert!(
+            rust.contains(sig),
+            "missing `{sig}` in the emitted library surface:\n{rust}"
+        );
+    }
+}
+
+#[test]
+fn library_crate_has_no_binary_entry_point() {
+    let rust = compile_lib("tests/regression/rust_lib_emit.tish");
+    // A `fn main` (or the iOS C entry) would make this an executable/staticlib, not an rlib.
+    assert!(
+        !rust.contains("fn main()"),
+        "a library crate must not emit a binary entry point:\n{rust}"
+    );
+    assert!(
+        !rust.contains("tish_ios_launch"),
+        "the iOS staticlib entry belongs to EmbeddedLib, not RustLib:\n{rust}"
+    );
+}
+
+#[test]
+fn exports_are_published_out_of_run_so_module_state_outlives_it() {
+    let rust = compile_lib("tests/regression/rust_lib_emit.tish");
+    // Without this call the closures — and the `VmRef` cells they captured — drop with `run()`'s
+    // frame, and every `pub fn` would see a fresh module on each call.
+    assert!(
+        rust.contains("__tish_publish_exports(::std::vec!["),
+        "run() must hand its exported bindings to the module table:\n{rust}"
+    );
+    assert!(
+        rust.contains("(\"clearAll\", clearAll.clone())"),
+        "each export must be published under its exported name:\n{rust}"
+    );
+    // `Value` is `!Send` unless `send-values` (which follows `http`) is on, so a `static` would not
+    // compile for the common configuration.
+    assert!(
+        rust.contains("thread_local! {") && rust.contains("static __TISH_MODULE"),
+        "module storage must be thread-local:\n{rust}"
+    );
+}
+
+#[test]
+fn runtime_prelude_is_re_exported_so_consumers_cannot_version_skew_value() {
+    let rust = compile_lib("tests/regression/rust_lib_emit.tish");
+    assert!(
+        rust.contains("pub use tishlang_runtime::{console_debug"),
+        "RustLib must re-export the runtime prelude (so `Value` comes from THIS crate):\n{rust}"
+    );
+    assert!(
+        rust.contains("pub use tishlang_runtime as runtime;"),
+        "RustLib must re-export the runtime module:\n{rust}"
+    );
+}
+
+#[test]
+fn other_emit_modes_keep_the_prelude_private_and_gain_no_surface() {
+    let path = fixture("tests/regression/rust_lib_emit.tish");
+    let rust = compile_project_full(&path, path.parent(), &[], true)
+        .expect("desktop emit")
+        .0;
+    assert!(
+        !rust.contains("__TISH_MODULE") && !rust.contains("pub fn clearAll"),
+        "the library surface must be RustLib-only:\n{rust}"
+    );
+    assert!(
+        rust.contains("use tishlang_runtime::{console_debug")
+            && !rust.contains("pub use tishlang_runtime::{console_debug"),
+        "a binary must keep the runtime prelude private:\n{rust}"
+    );
+}
+
+#[test]
+fn a_value_export_is_rejected_rather_than_silently_returning_null() {
+    // A value export has no arity and its Rust local need not even be a `Value` (a `const` string
+    // lowers to `&str`), so it cannot be published like a closure. Fail loudly instead.
+    let dir = std::env::temp_dir().join("tish_rustlib_value_export");
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("index.tish");
+    std::fs::write(&path, "export let answer = 42\nexport fn get() { return answer }\n").unwrap();
+    let err = compile_project_full_emit(
+        &path,
+        Some(dir.as_path()),
+        &[],
+        true,
+        NativeEmitMode::RustLib,
+        None,
+    )
+    .expect_err("a value export must be rejected");
+    assert!(
+        err.message.contains("only `export fn`") && err.message.contains("answer"),
+        "the error should name the offending export: {}",
+        err.message
+    );
+}
+
+#[test]
+fn an_entry_module_with_no_exports_is_rejected() {
+    let dir = std::env::temp_dir().join("tish_rustlib_no_exports");
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("index.tish");
+    std::fs::write(&path, "fn unused() { return 1 }\n").unwrap();
+    let err = compile_project_full_emit(
+        &path,
+        Some(dir.as_path()),
+        &[],
+        true,
+        NativeEmitMode::RustLib,
+        None,
+    )
+    .expect_err("a crate with no public API must be rejected");
+    assert!(
+        err.message.contains("exports nothing"),
+        "unexpected error: {}",
+        err.message
+    );
+}

package/crates/tish_fmt/src/lib.rs

@@ -1706,6 +1706,12 @@ impl Scanner {
         self.chars.get(self.i + 1).copied()
     }
 
+    /// True when the char immediately before the cursor is `:`, i.e. the `//` about to
+    /// be scanned is the scheme separator of a URL (`http://`) rather than a comment.
+    fn prev_is_colon(&self) -> bool {
+        self.i > 0 && self.chars.get(self.i - 1) == Some(&':')
+    }
+
     /// Consume one char, tracking line/col like the lexer (col resets after `\n`).
     fn bump(&mut self) -> Option<char> {
         let c = *self.chars.get(self.i)?;
@@ -1765,7 +1771,23 @@ impl Scanner {
                     self.seen_nonws = true;
                     self.scan_template();
                 }
-                '/' if self.peek2() == Some('/') => self.scan_line_comment(),
+                // `://` is a URL scheme separator, never a comment. This scanner has no JSX
+                // awareness, so JSX TEXT — which, unlike a string or an attribute value, is bare
+                // source — used to have its URLs read as comments:
+                //
+                //   <div>Redirect URI: http://127.0.0.1/callback</div>
+                //
+                // scanned `//127.0.0.1/callback</div>` as a line comment, and the printer then
+                // re-emitted it after the element. Worse, the re-emitted text is a REAL comment, so
+                // every subsequent run found one more and the file grew without converging — and
+                // `--check` could never pass on such a file. See tishlang/tish#578.
+                //
+                // Guarding on the preceding `:` fixes the whole class (http://, file://, dune://)
+                // without teaching this scanner to parse JSX, which would mean distinguishing
+                // `<div>` from `a < b` and risks breaking comment scanning in ordinary code.
+                '/' if self.peek2() == Some('/') && !self.prev_is_colon() => {
+                    self.scan_line_comment()
+                }
                 '/' if self.peek2() == Some('*') => self.scan_block_comment(),
                 ' ' | '\t' | '\r' | '\n' => {
                     self.bump();
@@ -1884,6 +1906,37 @@ mod tests {
         let _ = tishlang_parser::parse(&out).unwrap();
     }
 
+    /// tishlang/tish#578 — a URL in JSX TEXT had its `//` scanned as a line comment, so the
+    /// printer re-emitted everything after it as a trailing comment. The re-emitted text was
+    /// itself a real comment, so each run appended another copy and the file never converged.
+    #[test]
+    fn url_in_jsx_text_is_not_a_comment() {
+        let src = "/** @jsxImportSource lattish */\n\nexport fn Demo() {\n  return <div>Redirect URI: http://127.0.0.1/callback for details</div>\n}\n";
+        let once = format_source(src).unwrap();
+        // Not `!contains("//127.0.0.1")` — that substring is part of the legitimate URL. The
+        // corruption signature is the text appearing TWICE: once in the JSX, once hoisted out.
+        assert_eq!(
+            once.matches("127.0.0.1").count(),
+            1,
+            "URL text was duplicated into a comment:\n{once}"
+        );
+        // Idempotence is the property that actually broke: formatting must reach a fixed point,
+        // otherwise `--check` can never pass no matter how many times the file is formatted.
+        let twice = format_source(&once).unwrap();
+        assert_eq!(once, twice, "formatting is not idempotent");
+        let thrice = format_source(&twice).unwrap();
+        assert_eq!(twice, thrice, "formatting is not idempotent");
+    }
+
+    /// The guard keys off the `:` immediately before `//`, so ordinary trailing comments —
+    /// including ones right after a colon-bearing construct — must still be recognised.
+    #[test]
+    fn ordinary_comments_still_scanned() {
+        let src = "fn f() {\n  let o = { a: 1 } // trailing\n  return o\n}\n";
+        let out = format_source(src).unwrap();
+        assert!(out.contains("// trailing"), "comment was dropped:\n{out}");
+    }
+
     /// Debug-render the parsed AST with all `Span { … }` contents removed, so two programs compare
     /// equal iff they are structurally identical (reformatting legitimately changes spans).
     fn structure(src: &str) -> String {

package/crates/tish_lint/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang_lint"
-version = "3.1.0"
+version = "3.2.2"
 edition = "2021"
 description = "AST-based linter for Tish"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -149,6 +149,17 @@ pub fn build_via_cargo_with_config(
             project_root,
         );
     }
+    if build_config.artifact == NativeArtifact::RustLib {
+        return emit_rust_lib_crate(
+            rust_code,
+            native_modules,
+            output_path,
+            features,
+            extra_dependencies_toml,
+            generated_native_rs,
+            project_root,
+        );
+    }
 
     let out_stem = output_path
         .file_stem()
@@ -348,6 +359,122 @@ fn read_facade_agb_version(facade_path: &Path) -> Option<String> {
 /// Runs its own `cargo build` (NOT `run_cargo_build`) so the `.cargo/config.toml`
 /// rustflags (`-Tgba.ld`, `-Ctarget-cpu=arm7tdmi`) apply — `run_cargo_build` sets a
 /// `RUSTFLAGS` env that would shadow them.
+/// Read `version = "…"` from the `[package]` section of a crate's `Cargo.toml`.
+fn read_crate_version(crate_dir: &Path) -> Option<String> {
+    let toml = fs::read_to_string(crate_dir.join("Cargo.toml")).ok()?;
+    for line in toml.lines() {
+        let line = line.trim();
+        if let Some(rest) = line.strip_prefix("version") {
+            let rest = rest.trim_start();
+            if let Some(rest) = rest.strip_prefix('=') {
+                return Some(rest.trim().trim_matches('"').to_string());
+            }
+        }
+        // Only the first (package) table — stop before dependency versions.
+        if line.starts_with('[') && !line.starts_with("[package]") {
+            break;
+        }
+    }
+    None
+}
+
+/// `--target rust --emit lib`: write a Cargo **library source crate** to `output_path` and stop.
+///
+/// This is the one artifact that does not run cargo. The consumer decides what to build it for and
+/// how to depend on it, exactly as they would with any other crate — which is the point: it lets a
+/// Tish library be consumed from Rust the way `--target js` lets it be consumed from JS.
+///
+/// The `tishlang_runtime` dependency carries **both** `path` and `version`. Cargo prefers the path
+/// locally and falls back to the registry version when the crate is published, so the emitted crate
+/// is publishable without a post-processing step.
+fn emit_rust_lib_crate(
+    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 crate_name = tishlang_build_utils::cargo_target_name(
+        output_path
+            .file_name()
+            .and_then(|s| s.to_str())
+            .unwrap_or("tish_lib"),
+    );
+    let runtime_path = tishlang_build_utils::find_runtime_path_for_project(project_root)?;
+    let runtime_version = read_crate_version(Path::new(&runtime_path))
+        .map(|v| format!(", version = {:?}", v))
+        .unwrap_or_default();
+
+    let runtime_features = runtime_features_for_cargo(features);
+    let runtime_refs: Vec<&str> = runtime_features.iter().map(String::as_str).collect();
+    let features_str = if runtime_refs.is_empty() {
+        String::new()
+    } else {
+        format!(", features = {:?}", runtime_refs)
+    };
+
+    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();
+    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 lib_rs = if generated_native_rs.is_some() {
+        inject_generated_native_mod(rust_code)
+    } else {
+        rust_code.to_string()
+    };
+
+    let cargo_toml = format!(
+        r#"[package]
+name = "{name}"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "{name}"
+crate-type = ["rlib"]
+path = "src/lib.rs"
+
+[dependencies]
+tishlang_runtime = {{ path = {runtime:?}{version}{features} }}
+{more}"#,
+        name = crate_name,
+        runtime = runtime_path,
+        version = runtime_version,
+        features = features_str,
+        more = more_deps,
+    );
+
+    let src_dir = output_path.join("src");
+    fs::create_dir_all(&src_dir)
+        .map_err(|e| format!("Cannot create {}: {}", src_dir.display(), e))?;
+    fs::write(output_path.join("Cargo.toml"), cargo_toml)
+        .map_err(|e| format!("Cannot write Cargo.toml: {}", e))?;
+    if let Some(gen) = generated_native_rs {
+        fs::write(src_dir.join("generated_native.rs"), gen)
+            .map_err(|e| format!("Cannot write generated_native.rs: {}", e))?;
+    }
+    fs::write(src_dir.join("lib.rs"), lib_rs)
+        .map_err(|e| format!("Cannot write lib.rs: {}", e))?;
+
+    println!("Emitted Rust library crate: {}", output_path.display());
+    Ok(())
+}
+
 fn build_gba_rom(
     rust_code: &str,
     native_modules: Vec<ResolvedNativeModule>,

package/crates/tish_native/src/config.rs

@@ -11,6 +11,10 @@ pub enum NativeArtifact {
     /// A GBA ROM: cargo builds an ELF for `thumbv4t-none-eabi`, then `agb-gbafix`
     /// converts it to a `.gba`.
     GbaRom,
+    /// A Rust *library source crate* (`crate-type = ["rlib"]`) whose public API is the entry
+    /// module's `export fn`s. Unlike every other artifact, cargo is **not** run — the emitted
+    /// crate directory is itself the output, for the consumer to add as a path/registry dependency.
+    RustLib,
 }
 
 /// Options passed from the CLI into nested `cargo build`.
@@ -45,6 +49,16 @@ impl NativeBuildConfig {
         }
     }
 
+    /// `tish build --target rust --emit lib`: emit a Cargo library crate and stop. Host target —
+    /// the consumer decides what to build it for.
+    pub fn rust_lib() -> Self {
+        Self {
+            artifact: NativeArtifact::RustLib,
+            cargo_target: None,
+            emit_mode: NativeEmitMode::RustLib,
+        }
+    }
+
     pub fn is_cross_compile(&self) -> bool {
         self.cargo_target.is_some()
     }

package/crates/tish_runtime_gba/src/lib.rs

@@ -266,6 +266,23 @@ pub fn get_index(obj: &Value, index: &Value) -> Value {
     }
 }
 
+/// `&str` `s[i]` — char at a non-negative integer `idx`; non-int / negative / OOB → null.
+///
+/// Mirrors `tish_runtime::str_index`, and exists here because codegen emits a call to it whenever
+/// the indexed expression is statically a `&str` rather than a `Value` — which is what a module
+/// `const` string lowers to. Without it, `const D = "0123456789"` followed by `D[i]` is a hard
+/// E0425 on the GBA target only, while the identical code compiles and runs everywhere else.
+#[inline]
+pub fn str_index(s: &str, idx: &Value) -> Value {
+    match idx {
+        Value::Number(n) if *n >= 0.0 && n.fract() == 0.0 => match s.chars().nth(*n as usize) {
+            Some(c) => Value::String(c.to_string().into()),
+            None => Value::Null,
+        },
+        _ => Value::Null,
+    }
+}
+
 pub fn delete_property(obj: &Value, key: &Value) -> Value {
     match obj {
         Value::Object(m) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish-lint",
-  "version": "3.1.0",
+  "version": "3.2.2",
   "description": "Tish code linter",
   "license": "PIF",
   "repository": {