@tishlang/tish 2.9.0 → 2.12.0

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.9.0"
+version = "2.12.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = true }
@@ -59,6 +59,7 @@ 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 }
 

package/crates/tish/src/cli_help.rs

@@ -563,6 +563,14 @@ pub(crate) struct BuildArgs {
     /// 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,
+    /// For `--target js --format esm`: package the JSX runtime (`h`/`Fragment`) is auto-imported from when a module uses JSX without importing them (default `lattish`).
+    #[arg(
+        long = "jsx-import-source",
+        default_value = "lattish",
+        value_name = "PKG",
+        help_heading = "Options"
+    )]
+    pub jsx_import_source: 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>,
@@ -571,6 +579,42 @@ 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,
+    /// Package the JSX runtime (`h`/`Fragment`) is auto-imported from when a module uses JSX without importing them (default `lattish`).
+    #[arg(
+        long = "jsx-import-source",
+        default_value = "lattish",
+        value_name = "PKG",
+        help_heading = "Options"
+    )]
+    pub jsx_import_source: String,
+    /// 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)
@@ -579,6 +623,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());
@@ -137,8 +137,10 @@ fn main() {
                 a.ios_triple.as_deref(),
                 &a.crate_type,
                 &a.format,
+                &a.jsx_import_source,
             )
         }
+        Some(Commands::CompileModule(a)) => compile_module(&a),
         Some(Commands::DumpAst {
             file,
             ignore_indent,
@@ -543,6 +545,7 @@ fn compile_to_js(
     optimize: bool,
     source_map: bool,
     format: &str,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     if format != "bundle" && format != "esm" {
         return Err(format!(
@@ -573,7 +576,14 @@ fn compile_to_js(
         }
     });
     if format == "esm" {
-        return compile_to_js_esm(input_path, output_path, optimize, source_map, project_root);
+        return compile_to_js_esm(
+            input_path,
+            output_path,
+            optimize,
+            source_map,
+            project_root,
+            jsx_import_source,
+        );
     }
     let out_path = Path::new(output_path);
     let out_path = if out_path.extension().is_none()
@@ -655,6 +665,7 @@ fn compile_to_js_esm(
     optimize: bool,
     source_map: bool,
     project_root: Option<&Path>,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     if source_map {
         return Err(
@@ -670,8 +681,9 @@ fn compile_to_js_esm(
                 .into(),
         );
     }
-    let modules = tishlang_compile_js::compile_project_esm(input_path, project_root, optimize)
-        .map_err(|e| format!("{}", e))?;
+    let modules =
+        tishlang_compile_js::compile_project_esm(input_path, project_root, optimize, jsx_import_source)
+            .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))?;
@@ -703,6 +715,72 @@ fn compile_to_js_esm(
     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,
+        &args.jsx_import_source,
+    )
+    .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,
@@ -715,6 +793,7 @@ fn build_file(
     ios_triple: Option<&str>,
     crate_type: &str,
     format: &str,
+    jsx_import_source: &str,
 ) -> Result<(), String> {
     let optimize = !no_optimize;
     let input_path = Path::new(input_path)
@@ -724,7 +803,14 @@ 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, format);
+        return compile_to_js(
+            &input_path,
+            output_path,
+            optimize,
+            source_map,
+            format,
+            jsx_import_source,
+        );
     }
 
     // `wasm-gpu` (#277): same pipeline as `wasm` but builds the `--features gpu` WebGPU runtime and

package/crates/tish/tests/integration_test.rs

@@ -738,6 +738,183 @@ fn test_js_esm_export_collision() {
     }
 }
 
+/// #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}"
+    );
+}
+
+/// #291: `compile-module` auto-imports the JSX runtime (`h` / `Fragment`) when a module uses JSX
+/// but doesn't import them itself, so per-module ESM output doesn't throw `ReferenceError` at load.
+/// `--jsx-import-source` overrides the runtime package.
+#[test]
+fn test_compile_module_jsx_auto_imports_runtime() {
+    let bin = tish_bin();
+    if !bin.exists() {
+        return;
+    }
+    let widget = workspace_root()
+        .join("tests")
+        .join("modules")
+        .join("esm")
+        .join("vite_hmr")
+        .join("widget.tish");
+    if !widget.exists() {
+        return;
+    }
+    // Default runtime source (`lattish`), Vite-dev so the specifier stays bare.
+    let out = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&widget)
+        .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("import { h, Fragment } from \"lattish\";"),
+        "JSX module with a fragment auto-imports both h and Fragment:\n{stdout}"
+    );
+
+    // Custom runtime source via --jsx-import-source.
+    let out2 = Command::new(&bin)
+        .args(["compile-module"])
+        .arg(&widget)
+        .args([
+            "--target",
+            "js",
+            "--format",
+            "esm",
+            "--vite-dev",
+            "--no-source-map",
+            "--jsx-import-source",
+            "@tishlang/lattish",
+        ])
+        .current_dir(workspace_root())
+        .output()
+        .expect("run compile-module");
+    assert!(out2.status.success());
+    let stdout2 = String::from_utf8_lossy(&out2.stdout);
+    assert!(
+        stdout2.contains("from \"@tishlang/lattish\";"),
+        "--jsx-import-source overrides the runtime package:\n{stdout2}"
+    );
+}
+
 /// Ignored: tishlang_eval::run() does not run the event loop.
 #[test]
 #[cfg(feature = "http")]