@tishlang/tish 2.8.0 → 2.10.1

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.8.0"
+version = "2.10.1"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -59,8 +59,10 @@ tishlang_runtime = { path = "../tish_runtime", version = ">=0.1" }
 tishlang_core = { path = "../tish_core", version = ">=0.1" }
 tishlang_js_to_tish = { path = "../js_to_tish", version = ">=0.1" }
 clap = { version = "4.6.0", features = ["derive", "color"] }
+serde_json = "1"
 tishlang_pg = { path = "../tish_pg", version = ">=0.1", optional = true }
 mimalloc = { version = "0.1", optional = true }
 
 [dev-dependencies]
 rayon = "1.11"
+tempfile = "3"

package/crates/tish/src/cli_help.rs

@@ -560,6 +560,9 @@ pub(crate) struct BuildArgs {
     /// For `--target js` project builds: emit `OUTPUT.js.map` and `//# sourceMappingURL=…` so JS/TS tools can jump to original `.tish` (implies `--no-optimize` for that build).
     #[arg(long, help_heading = "Options")]
     pub source_map: bool,
+    /// For `--target js`: `bundle` (default) merges all modules into one file; `esm` emits one `.js` per `.tish` module with real `import`/`export` (so `-o` is a directory) for Vite/Rollup tree-shaking.
+    #[arg(long, default_value = "bundle", value_name = "FORMAT", help_heading = "Options")]
+    pub format: String,
     /// Run the gradual type checker: `warn` prints `line:col` type diagnostics; `error` also fails the build on them. (Equivalent to setting `TISH_CHECK`.)
     #[arg(long, value_name = "MODE", help_heading = "Options")]
     pub check: Option<String>,
@@ -568,6 +571,34 @@ pub(crate) struct BuildArgs {
     pub file: String,
 }
 
+#[derive(Parser)]
+pub(crate) struct CompileModuleArgs {
+    /// `--target js` only (the single-module ESM path is JS-specific).
+    #[arg(long, default_value = "js", value_name = "TARGET", help_heading = "Options")]
+    pub target: String,
+    /// `--format esm` only (one ES module per file).
+    #[arg(long, default_value = "esm", value_name = "FORMAT", help_heading = "Options")]
+    pub format: String,
+    /// Keep relative `.tish` specifiers and bare packages verbatim so Vite's resolveId/load re-enters the plugin per module (in-graph HMR). Omit for disk-style `.tish`->`.js` rewriting.
+    #[arg(long, help_heading = "Options")]
+    pub vite_dev: bool,
+    /// Emit a v3 source map back to the `.tish` source as a `{ "js", "map" }` JSON envelope on stdout (on by default; implies no optimization).
+    #[arg(long, help_heading = "Options")]
+    pub source_map: bool,
+    /// Disable the source map; print raw ES module JS to stdout instead of the JSON envelope.
+    #[arg(long = "no-source-map", help_heading = "Options")]
+    pub no_source_map: bool,
+    /// Project root for resolving bare specifiers / `node_modules` (defaults to the file's parent).
+    #[arg(long, value_name = "DIR", help_heading = "Options")]
+    pub project_root: Option<String>,
+    /// Disable AST optimizations (forced on when a source map is emitted).
+    #[arg(long, help_heading = "Options")]
+    pub no_optimize: bool,
+    /// Entry `.tish` file to compile (only this file is read; dependencies are left to the bundler).
+    #[arg(required = true, value_name = "FILE", help_heading = "Arguments")]
+    pub file: String,
+}
+
 #[derive(Subcommand)]
 pub(crate) enum Commands {
     /// Run a Tish file (interpret)
@@ -576,6 +607,9 @@ pub(crate) enum Commands {
     Repl(ReplArgs),
     /// Build native binary, wasm, wasi, or JavaScript output
     Build(BuildArgs),
+    /// Compile a single `.tish` module to one ES module (for Vite dev / HMR); prints to stdout
+    #[command(name = "compile-module")]
+    CompileModule(CompileModuleArgs),
     /// Parse and dump AST
     #[command(name = "dump-ast")]
     DumpAst {

package/crates/tish/src/main.rs

@@ -22,7 +22,7 @@ use tishlang_core::VmRef;
 use clap::FromArgMatches;
 use rustyline::{Behavior, ColorMode, CompletionType, Config, Editor};
 
-use cli_help::{Cli, Commands};
+use cli_help::{Cli, Commands, CompileModuleArgs};
 
 /// Normalize `--feature` / `--feature http,timers,fs` / `--feature full` for VM runs and native builds.
 fn normalize_capability_flags(features: &[String]) -> HashSet<String> {
@@ -73,7 +73,7 @@ fn native_build_features_from_cli(cli_features: &[String]) -> Vec<String> {
 fn argv_with_implicit_run(mut argv: Vec<String>) -> Vec<String> {
     if argv.len() >= 2 {
         let first = argv[1].as_str();
-        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "dump-ast"];
+        const SUBCOMMANDS: &[&str] = &["run", "repl", "build", "compile-module", "dump-ast"];
         let looks_like_file = !first.starts_with('-') && !SUBCOMMANDS.contains(&first);
         if looks_like_file {
             argv.insert(1, "run".to_string());
@@ -136,8 +136,10 @@ fn main() {
                 a.source_map,
                 a.ios_triple.as_deref(),
                 &a.crate_type,
+                &a.format,
             )
         }
+        Some(Commands::CompileModule(a)) => compile_module(&a),
         Some(Commands::DumpAst {
             file,
             ignore_indent,
@@ -541,7 +543,14 @@ fn compile_to_js(
     output_path: &str,
     optimize: bool,
     source_map: bool,
+    format: &str,
 ) -> Result<(), String> {
+    if format != "bundle" && format != "esm" {
+        return Err(format!(
+            "Unknown --format '{}' for --target js. Use 'bundle' (single merged file) or 'esm' (one file per module).",
+            format
+        ));
+    }
     if source_map && optimize {
         return Err(
             "tish build --target js --source-map requires --no-optimize (mappings follow unmerged statement order)."
@@ -564,6 +573,9 @@ fn compile_to_js(
             Some(p)
         }
     });
+    if format == "esm" {
+        return compile_to_js_esm(input_path, output_path, optimize, source_map, project_root);
+    }
     let out_path = Path::new(output_path);
     let out_path = if out_path.extension().is_none()
         || out_path.extension() == Some(std::ffi::OsStr::new(""))
@@ -635,6 +647,128 @@ fn compile_to_js(
     Ok(())
 }
 
+/// `--target js --format esm`: emit one `.js` per `.tish` module under the output directory,
+/// preserving the source tree layout, with real ES `import`/`export` so a bundler (Vite/Rollup)
+/// can tree-shake and code-split. `-o` is treated as a directory.
+fn compile_to_js_esm(
+    input_path: &Path,
+    output_path: &str,
+    optimize: bool,
+    source_map: bool,
+    project_root: Option<&Path>,
+) -> Result<(), String> {
+    if source_map {
+        return Err(
+            "tish build --target js --format esm does not yet support --source-map; use --format bundle for source maps."
+                .into(),
+        );
+    }
+    if input_path.extension().map(|e| e == "jsx") == Some(true)
+        || input_path.extension().map(|e| e == "js") == Some(true)
+    {
+        return Err(
+            "tish build --target js --format esm is only supported for .tish entry files; use --format bundle for .jsx / .js inputs."
+                .into(),
+        );
+    }
+    let modules = tishlang_compile_js::compile_project_esm(input_path, project_root, optimize)
+        .map_err(|e| format!("{}", e))?;
+    let out_dir = Path::new(output_path);
+    fs::create_dir_all(out_dir)
+        .map_err(|e| format!("Cannot create output directory {}: {}", out_dir.display(), e))?;
+    for module in &modules {
+        let out = out_dir.join(&module.relative_path);
+        if let Some(parent) = out.parent() {
+            fs::create_dir_all(parent)
+                .map_err(|e| format!("Cannot create output directory {}: {}", parent.display(), e))?;
+        }
+        fs::write(&out, &module.js)
+            .map_err(|e| format!("Cannot write {}: {}", out.display(), e))?;
+    }
+    println!("Built {} module(s) to {}", modules.len(), out_dir.display());
+    // The entry may sit in a subtree (the output is rooted at the directory common to every module,
+    // which can be an ancestor of the entry when deps live in sibling packages / node_modules), so
+    // point the user at the actual entry `.js` they should hand to a bundler.
+    let entry_js = input_path
+        .canonicalize()
+        .unwrap_or_else(|_| input_path.to_path_buf())
+        .with_extension("js");
+    if let Some(entry_rel) = modules
+        .iter()
+        .filter(|m| entry_js.ends_with(&m.relative_path))
+        .max_by_key(|m| m.relative_path.components().count())
+        .map(|m| m.relative_path.clone())
+    {
+        println!("Entry: {}", out_dir.join(entry_rel).display());
+    }
+    Ok(())
+}
+
+/// `tish compile-module FILE` (#284): compile a single `.tish` file to one ES module and print it
+/// to stdout. This is the fast, in-graph path the Vite plugin shells out to in `load()` — only the
+/// one file is read (no dependency graph resolution), so Vite owns the module graph and can HMR a
+/// leaf module without a full reload.
+///
+/// With a source map (default), stdout is a JSON envelope `{"js":…,"map":…}` so the plugin gets
+/// both artifacts from one spawn; with `--no-source-map`, stdout is raw ES module JS.
+fn compile_module(args: &CompileModuleArgs) -> Result<(), String> {
+    if args.target != "js" {
+        return Err(format!(
+            "tish compile-module only supports --target js (got '{}').",
+            args.target
+        ));
+    }
+    if args.format != "esm" {
+        return Err(format!(
+            "tish compile-module only supports --format esm (got '{}').",
+            args.format
+        ));
+    }
+    let input_path = Path::new(&args.file)
+        .canonicalize()
+        .map_err(|e| format!("Cannot resolve {}: {}", args.file, e))?;
+    if input_path.extension().map(|e| e != "tish").unwrap_or(true) {
+        return Err(format!(
+            "tish compile-module expects a .tish file (got '{}').",
+            args.file
+        ));
+    }
+    let want_map = !args.no_source_map;
+    // A source map needs unmerged statement order, so it forces no optimization (same rule as
+    // `build --target js --source-map`).
+    let optimize = !args.no_optimize && !want_map;
+    let import_rewrite = if args.vite_dev {
+        tishlang_compile_js::ImportRewrite::ViteDev
+    } else {
+        tishlang_compile_js::ImportRewrite::Disk
+    };
+    let project_root = args
+        .project_root
+        .as_ref()
+        .map(PathBuf::from)
+        .or_else(|| input_path.parent().map(Path::to_path_buf));
+    let bundle = tishlang_compile_js::compile_module_esm(
+        &input_path,
+        project_root.as_deref(),
+        optimize,
+        import_rewrite,
+        want_map,
+    )
+    .map_err(|e| format!("{}", e))?;
+
+    if let Some(map_json) = bundle.source_map_json {
+        let map: serde_json::Value = serde_json::from_str(&map_json)
+            .map_err(|e| format!("Internal: source map is not valid JSON: {}", e))?;
+        let envelope = serde_json::json!({ "js": bundle.js, "map": map });
+        let line = serde_json::to_string(&envelope)
+            .map_err(|e| format!("Cannot serialize compile-module output: {}", e))?;
+        println!("{}", line);
+    } else {
+        print!("{}", bundle.js);
+    }
+    Ok(())
+}
+
 #[allow(clippy::vec_init_then_push, clippy::too_many_arguments)] // build_file maps CLI build flags 1:1
 fn build_file(
     input_path: &str,
@@ -646,6 +780,7 @@ fn build_file(
     source_map: bool,
     ios_triple: Option<&str>,
     crate_type: &str,
+    format: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -655,7 +790,7 @@ fn build_file(
     let is_js = input_path.extension().map(|e| e == "js") == Some(true);
 
     if target == "js" {
-        return compile_to_js(&input_path, output_path, optimize, source_map);
+        return compile_to_js(&input_path, output_path, optimize, source_map, format);
     }
 
     // `wasm-gpu` (#277): same pipeline as `wasm` but builds the `--features gpu` WebGPU runtime and

package/crates/tish/tests/integration_test.rs

@@ -673,6 +673,179 @@ fn test_module_private_binding_isolation() {
     }
 }
 
+/// #282: `--target js --format esm` emits one ES module per `.tish` file with real
+/// `import`/`export`, so two modules exporting the same name (`export fn activate`) keep separate
+/// scopes instead of colliding. The merge-based pipeline (interp/VM/native and `--format bundle`)
+/// still flattens both into one scope — a separately-tracked collision — so this test pins the ESM
+/// JS target, which is the path that isolates them. Builds the module tree and runs it under Node.
+#[test]
+fn test_js_esm_export_collision() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let main = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("export_collision")
+        .join("main.tish");
+    if !main.exists() {
+        return;
+    }
+    let expected = "ab\n";
+
+    // JS ESM target: build the module tree, then load + run the entry under Node.
+    let node_available = Command::new("node")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    if node_available {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let out_dir = tmp.path().join("esm_out");
+        let build = Command::new(&bin)
+            .args(["build"])
+            .arg(&main)
+            .args(["-o"])
+            .arg(&out_dir)
+            .args(["--target", "js", "--format", "esm"])
+            .current_dir(workspace_root())
+            .output()
+            .expect("build esm");
+        assert!(
+            build.status.success(),
+            "esm build failed: stderr={}",
+            String::from_utf8_lossy(&build.stderr)
+        );
+        let entry = out_dir.join("main.js");
+        assert!(entry.exists(), "esm entry {} not emitted", entry.display());
+        let out = Command::new("node")
+            .arg(&entry)
+            .current_dir(workspace_root())
+            .output()
+            .expect("run node");
+        assert!(
+            out.status.success(),
+            "esm JS run failed (collision not isolated?): stderr={}",
+            String::from_utf8_lossy(&out.stderr)
+        );
+        assert_eq!(
+            String::from_utf8_lossy(&out.stdout),
+            expected,
+            "esm export_collision mismatch on JS ESM target"
+        );
+    }
+}
+
+/// #284: `tish compile-module --vite-dev --source-map` compiles a single `.tish` file (no graph
+/// resolution) to one ES module, keeps relative `.tish` specifiers, and emits a `{ js, map }` JSON
+/// envelope whose map references the `.tish` source. This is the in-graph path the Vite plugin uses.
+#[test]
+fn test_compile_module_vite_dev_with_source_map() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let main = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("main.tish");
+    if !main.exists() {
+        return;
+    }
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&main)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--source-map",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(
+        out.status.success(),
+        "compile-module failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    let parsed: serde_json::Value =
+        serde_json::from_str(&stdout).unwrap_or_else(|e| panic!("stdout is not JSON: {e}\n{stdout}"));
+    let js = parsed["js"].as_str().expect("envelope has string `js`");
+    assert!(
+        js.contains("import { makeCounter } from \"./counter.tish\";"),
+        "Vite-dev keeps the .tish specifier:\n{js}"
+    );
+    assert!(
+        !js.contains("./counter.js"),
+        "Vite-dev must not rewrite .tish to .js:\n{js}"
+    );
+    let map = &parsed["map"];
+    assert!(map.is_object(), "envelope has object `map`: {map}");
+    assert_eq!(map["version"], serde_json::json!(3), "v3 source map");
+    let sources = map["sources"].as_array().expect("map has sources");
+    assert!(
+        sources
+            .iter()
+            .any(|s| s.as_str().map(|s| s.contains("main.tish")).unwrap_or(false)),
+        "map sources reference the .tish file: {sources:?}"
+    );
+}
+
+/// #284: without `--source-map`, `compile-module` prints raw ES module JS to stdout (no envelope),
+/// so the output can be consumed directly.
+#[test]
+fn test_compile_module_no_source_map_prints_raw_js() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let counter = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("counter.tish");
+    if !counter.exists() {
+        return;
+    }
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&counter)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--no-source-map",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(
+        out.status.success(),
+        "compile-module failed: stderr={}",
+        String::from_utf8_lossy(&out.stderr)
+    );
+    let stdout = String::from_utf8_lossy(&out.stdout);
+    assert!(
+        stdout.contains("export function makeCounter"),
+        "raw JS output includes the export:\n{stdout}"
+    );
+    assert!(
+        !stdout.trim_start().starts_with('{'),
+        "no-source-map output is raw JS, not a JSON envelope:\n{stdout}"
+    );
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]