@tishlang/tish-lint 3.0.0 → 3.2.2

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/src/resolve.rs

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

package/crates/tish_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_core/src/shape.rs

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

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.0.0"
+version = "3.2.2"
 edition = "2021"
 description = "AST-based linter for Tish"
 license-file = { workspace = true }

package/crates/tish_native/src/build.rs

@@ -18,6 +18,10 @@ const RUNTIME_CARGO_FEATURES: &[&str] = &[
     "ws",
     "tty",
     "pty",
+    "net",
+    "encoding",
+    "crypto",
+    "zip",
 ];
 
 /// Map CLI/compile features to flags passed to `tishlang_runtime` in the temp crate's Cargo.toml.
@@ -145,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()
@@ -344,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/Cargo.toml

@@ -56,6 +56,15 @@ http-hyper = [
 # `mkdtemp` needs a random suffix (predictable/timestamp names are a temp-dir security smell).
 fs = ["promise", "dep:rand"]
 process = []
+# Raw TCP sockets: DAP TCP transports, OAuth loopback listener, connect probes.
+net = []
+# Base64 encode/decode (tish:encoding) — bytes <-> string, for file-bytes-over-JSON (extension host
+# vscode.workspace.fs, broker_read_file_base64) and PKCE (URL-safe, no-pad).
+encoding = ["dep:base64"]
+# SHA-256 + secure random (tish:crypto) — PKCE code_challenge/verifier, checkpoint dir hashing.
+crypto = ["dep:sha2", "dep:rand"]
+# Zip extraction (tish:zip) — VSIX / archive extract with `..`-traversal guard + unix-mode preserved.
+zip = ["dep:zip"]
 # Interactive terminal I/O (issue #101): raw mode, key/resize events, size, alt screen.
 tty = ["dep:crossterm"]
 # Pseudoterminal hosting (issue #493): spawn a shell/program on a real PTY, read/write/resize/kill —
@@ -71,6 +80,7 @@ ws = [
     "tokio/net",
     "tokio/io-util",
     "dep:tokio-tungstenite",
+    "dep:rustls",
     "dep:futures-util",
     "dep:lazy_static",
     "send-values",
@@ -84,6 +94,9 @@ tishlang_builtins = { path = "../tish_builtins", version = ">=0.1" }
 tokio = { version = "1.50.0", features = ["rt-multi-thread", "macros", "time", "sync"], optional = true }
 reqwest = { version = "0.13.2", default-features = false, features = ["rustls", "json", "stream", "multipart"], optional = true }
 futures = { version = "0.3.32", optional = true }
+base64 = { version = "0.22", optional = true }
+sha2 = { version = "0.10", optional = true }
+zip = { version = "2", default-features = false, features = ["deflate"], optional = true }
 bytes = { version = "1", optional = true }
 tiny_http = { version = "0.12.0", optional = true }
 # fs feature only: random suffix for `mkdtemp`.
@@ -100,7 +113,13 @@ hyper = { version = "1", default-features = false, features = ["server", "http1"
 hyper-util = { version = "0.1", features = ["server", "tokio"], optional = true }
 http-body-util = { version = "0.1", optional = true }
 core_affinity = { version = "0.8", optional = true }
-tokio-tungstenite = { version = "0.29", optional = true }
+# rustls-tls-native-roots gives `wss://` support (system cert store, no OpenSSL — matches reqwest's
+# rustls backend). Without a TLS feature, connect_async can only do plain `ws://` and rejects wss.
+tokio-tungstenite = { version = "0.29", optional = true, features = ["rustls-tls-native-roots"] }
+# Direct rustls handle so ws.rs can install a process-default CryptoProvider: both aws-lc-rs and ring
+# are in the tree (reqwest + transitive), so rustls 0.23 can't auto-select one, and connect_async's
+# wss path needs the process default. aws_lc_rs matches reqwest's provider.
+rustls = { version = "0.23", default-features = false, features = ["aws_lc_rs"], optional = true }
 futures-util = { version = "0.3", optional = true }
 lazy_static = { version = "1", optional = true }