@tishlang/tish 2.9.0 → 2.12.0

package/crates/tish_compile_js/src/codegen.rs

@@ -11,6 +11,10 @@ use tishlang_ast::{
 
 use crate::error::CompileError;
 
+/// Default module specifier the JSX runtime (`h` / `Fragment`) is auto-imported from (issue #291).
+/// Matches the repo convention (`import { h } from "lattish"`); overridable via `--jsx-import-source`.
+pub const DEFAULT_JSX_IMPORT_SOURCE: &str = "lattish";
+
 /// JS output mode. `Bundle` flattens every module into one file (imports/exports are resolved away
 /// by `merge_modules`). `Esm` emits one file per module with real ES `import`/`export` statements so
 /// a bundler (Vite/Rollup) can tree-shake and code-split. See issue #177's sibling, #282.
@@ -20,16 +24,31 @@ enum EmitMode {
     Esm,
 }
 
+/// How ESM import specifiers are rewritten. `Disk` (production `--format esm`) rewrites `.tish`
+/// specifiers to their sibling `.js` output paths and resolves bare specifiers to relative paths
+/// into the emitted module tree. `ViteDev` keeps relative `.tish` specifiers and bare specifiers
+/// as-is so Vite's `resolveId`/`load` re-enters the plugin per module (in-graph HMR, issue #284).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImportRewrite {
+    Disk,
+    ViteDev,
+}
+
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
     emit_mode: EmitMode,
+    /// ESM only: how import specifiers are rewritten (disk `.js` paths vs Vite-dev `.tish`).
+    import_rewrite: ImportRewrite,
     /// ESM only: the absolute path of the module being emitted (the importer), used to rewrite
     /// relative/bare import specifiers to sibling `.js` output paths.
     module_path: PathBuf,
     /// ESM only: the project root, so import targets can be located relative to the output tree.
     project_root: PathBuf,
+    /// ESM only: the module specifier the JSX runtime (`h` / `Fragment`) is auto-imported from when a
+    /// module uses JSX but doesn't import them itself (issue #291). Defaults to `lattish`.
+    jsx_import_source: String,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -48,19 +67,28 @@ impl Codegen {
             indent: 0,
             in_async: false,
             emit_mode: EmitMode::Bundle,
+            import_rewrite: ImportRewrite::Disk,
             module_path: PathBuf::new(),
             project_root: PathBuf::new(),
+            jsx_import_source: DEFAULT_JSX_IMPORT_SOURCE.to_string(),
         }
     }
 
-    fn new_esm(module_path: PathBuf, project_root: PathBuf) -> Self {
+    fn new_esm(
+        module_path: PathBuf,
+        project_root: PathBuf,
+        import_rewrite: ImportRewrite,
+        jsx_import_source: String,
+    ) -> Self {
         Self {
             output: String::new(),
             indent: 0,
             in_async: false,
             emit_mode: EmitMode::Esm,
+            import_rewrite,
             module_path,
             project_root,
+            jsx_import_source,
         }
     }
 
@@ -125,6 +153,7 @@ impl Codegen {
         map_builder: Option<&mut SourceMapBuilder>,
     ) -> Result<(), CompileError> {
         self.write("// Generated by tishlang_compile_js\n");
+        self.emit_jsx_runtime_auto_import(program)?;
         match (map_sources, map_builder) {
             (Some((srcs, root)), Some(sm)) => {
                 for (i, stmt) in program.statements.iter().enumerate() {
@@ -162,6 +191,34 @@ impl Codegen {
         Ok(())
     }
 
+    /// Auto-import the JSX runtime (`h` / `Fragment`) for ESM modules that use JSX but don't bring
+    /// those bindings into scope themselves (issue #291). In `--format bundle` the merged scope makes
+    /// a single `lattish` import visible everywhere, but each ES module is its own scope, so a JSX
+    /// module that didn't `import { h }` throws `ReferenceError` at load. We inject only the missing
+    /// names (so an explicit `import { h }` isn't duplicated) from `jsx_import_source`, rewritten the
+    /// same way as user imports (disk `.js` path vs. Vite-dev bare specifier). No-op outside ESM.
+    fn emit_jsx_runtime_auto_import(&mut self, program: &Program) -> Result<(), CompileError> {
+        if self.emit_mode != EmitMode::Esm {
+            return Ok(());
+        }
+        let needed = tishlang_ui::jsx::jsx_runtime_imports_needed(program);
+        if needed.is_empty() {
+            return Ok(());
+        }
+        let spec = rewrite_import_to_js(
+            &self.jsx_import_source,
+            &self.module_path,
+            &self.project_root,
+            self.import_rewrite,
+        )?;
+        self.writeln(&format!(
+            "import {{ {} }} from \"{}\";",
+            needed.join(", "),
+            spec
+        ));
+        Ok(())
+    }
+
     fn emit_statement(&mut self, stmt: &Statement) -> Result<(), CompileError> {
         match stmt {
             Statement::Block { statements, .. } => {
@@ -907,7 +964,12 @@ impl Codegen {
         specifiers: &[ImportSpecifier],
         from: &str,
     ) -> Result<(), CompileError> {
-        let spec = rewrite_import_to_js(from, &self.module_path, &self.project_root)?;
+        let spec = rewrite_import_to_js(
+            from,
+            &self.module_path,
+            &self.project_root,
+            self.import_rewrite,
+        )?;
         let mut named: Vec<String> = Vec::new();
         let mut default_local: Option<String> = None;
         let mut namespace_local: Option<String> = None;
@@ -987,6 +1049,7 @@ fn rewrite_import_to_js(
     spec: &str,
     importer_abs: &Path,
     project_root: &Path,
+    rewrite: ImportRewrite,
 ) -> Result<String, CompileError> {
     if tishlang_compile::is_native_import(spec) {
         return Err(CompileError {
@@ -996,6 +1059,11 @@ fn rewrite_import_to_js(
             ),
         });
     }
+    // Vite dev keeps specifiers verbatim: relative `.tish` paths and bare packages are left for the
+    // plugin's `resolveId`/`load` (relative) or Node/Vite resolution (bare) to handle per-module.
+    if rewrite == ImportRewrite::ViteDev {
+        return Ok(spec.to_string());
+    }
     if spec.starts_with("./") || spec.starts_with("../") {
         return Ok(spec_ext_to_js(spec));
     }
@@ -1210,6 +1278,7 @@ pub fn compile_project_esm(
     entry_path: &Path,
     project_root: Option<&Path>,
     optimize: bool,
+    jsx_import_source: &str,
 ) -> Result<Vec<EmittedJsModule>, CompileError> {
     let modules = tishlang_compile::resolve_project(entry_path, project_root)
         .map_err(|e| CompileError { message: e })?;
@@ -1249,7 +1318,12 @@ pub fn compile_project_esm(
         } else {
             module.program.clone()
         };
-        let mut gen = Codegen::new_esm(mod_canon.clone(), res_root_canon.clone());
+        let mut gen = Codegen::new_esm(
+            mod_canon.clone(),
+            res_root_canon.clone(),
+            ImportRewrite::Disk,
+            jsx_import_source.to_string(),
+        );
         gen.emit_program(&program, None, None)?;
         out.push(EmittedJsModule {
             relative_path: rel_js,
@@ -1259,6 +1333,90 @@ pub fn compile_project_esm(
     Ok(out)
 }
 
+/// Compile a **single** `.tish` module to one ES module (issue #284, Vite dev / HMR). Unlike
+/// [`compile_project_esm`], the dependency graph is **not** resolved — only `module_path` is read
+/// and parsed — so a Vite plugin can compile one file per `load()` and let Vite own the module
+/// graph. With `ImportRewrite::ViteDev` relative `.tish` specifiers and bare packages are preserved
+/// so Vite re-enters the plugin per dependency. When `source_map` is set, a v3 map back to the
+/// `.tish` source is returned (requires `optimize == false`, matching the bundle source-map rule).
+pub fn compile_module_esm(
+    module_path: &Path,
+    project_root: Option<&Path>,
+    optimize: bool,
+    import_rewrite: ImportRewrite,
+    source_map: bool,
+    jsx_import_source: &str,
+) -> Result<JsBundle, CompileError> {
+    if source_map && optimize {
+        return Err(CompileError {
+            message: "source map requires no optimization (mappings follow unmerged statement order)."
+                .into(),
+        });
+    }
+    let source = std::fs::read_to_string(module_path).map_err(|e| CompileError {
+        message: format!("Cannot read {}: {}", module_path.display(), e),
+    })?;
+    let parsed = tishlang_parser::parse(&source).map_err(|e| CompileError {
+        message: format!("Parse error in {}: {}", module_path.display(), e),
+    })?;
+    let program = if optimize {
+        tishlang_opt::optimize(&parsed)
+    } else {
+        parsed
+    };
+    let module_canon = module_path
+        .canonicalize()
+        .unwrap_or_else(|_| module_path.to_path_buf());
+    let root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| module_path.parent().map(Path::to_path_buf))
+        .unwrap_or_else(|| PathBuf::from("."));
+    let root_canon = root.canonicalize().unwrap_or(root);
+
+    let mut gen = Codegen::new_esm(
+        module_canon.clone(),
+        root_canon.clone(),
+        import_rewrite,
+        jsx_import_source.to_string(),
+    );
+    if source_map {
+        let stmt_sources = vec![module_canon.clone(); program.statements.len()];
+        let mut builder = SourceMapBuilder::new(Some("module.js"));
+        builder.set_source_root(Some(""));
+        gen.emit_program(
+            &program,
+            Some((stmt_sources.as_slice(), root_canon.as_path())),
+            Some(&mut builder),
+        )?;
+        let mut sm = builder.into_sourcemap();
+        // Embed the original `.tish` so consumers (Vite, browser devtools) never resolve
+        // `sources` from disk. The map's `sources` are project-root-relative, but Vite resolves
+        // them against the module's own directory; without inline content it logs
+        // "Sourcemap ... points to missing source files" and devtools can't show the original.
+        let source_count = sm.get_source_count();
+        for id in 0..source_count {
+            sm.set_source_contents(id, Some(&source));
+        }
+        let mut v = Vec::new();
+        sm.to_writer(&mut v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        let map_json = String::from_utf8(v).map_err(|e| CompileError {
+            message: e.to_string(),
+        })?;
+        Ok(JsBundle {
+            js: gen.output,
+            source_map_json: Some(map_json),
+        })
+    } else {
+        gen.emit_program(&program, None, None)?;
+        Ok(JsBundle {
+            js: gen.output,
+            source_map_json: None,
+        })
+    }
+}
+
 /// Deepest directory that is an ancestor of every given file path, compared component-wise. Used as
 /// the base of the `--format esm` output tree so modules outside the entry's project root (sibling
 /// packages, `node_modules`) still map to a stable, collision-free location. For a single file this

package/crates/tish_compile_js/src/lib.rs

@@ -8,12 +8,16 @@ mod error;
 mod tests_jsx;
 
 pub use codegen::{
-    compile_project_esm, compile_project_with_jsx, compile_project_with_jsx_and_source_map,
-    compile_with_jsx, EmittedJsModule, JsBundle,
+    compile_module_esm, compile_project_esm, compile_project_with_jsx,
+    compile_project_with_jsx_and_source_map, compile_with_jsx, EmittedJsModule, ImportRewrite,
+    JsBundle, DEFAULT_JSX_IMPORT_SOURCE,
 };
 pub use error::CompileError;
 
-/// JSX lowers to `h` / `Fragment`; merge the `lattish` runtime for hooks and DOM.
+/// Compile a single program to a bundle-style JS string. JSX lowers to `h` / `Fragment`; in bundle
+/// mode those resolve against the merged scope (merge the `lattish` runtime for hooks and DOM). The
+/// per-module ESM paths ([`compile_module_esm`] / [`compile_project_esm`]) auto-import the runtime
+/// for JSX modules that don't import it themselves (issue #291).
 pub fn compile(program: &tishlang_ast::Program, optimize: bool) -> Result<String, CompileError> {
     compile_with_jsx(program, optimize)
 }

package/crates/tish_compile_js/src/tests_jsx.rs

@@ -4,7 +4,10 @@ mod tests {
 
     use tishlang_parser::parse;
 
-    use crate::{compile_project_esm, compile_project_with_jsx, compile_with_jsx, EmittedJsModule};
+    use crate::{
+        compile_module_esm, compile_project_esm, compile_project_with_jsx, compile_with_jsx,
+        EmittedJsModule, ImportRewrite,
+    };
 
     #[test]
     fn lattish_jsx_emits_h_with_children_array() {
@@ -472,7 +475,8 @@ fn factory() {
             f.write_all(src.as_bytes()).unwrap();
             f.sync_all().unwrap();
         }
-        compile_project_esm(&dir.join(entry), Some(dir), false).expect("compile_project_esm failed")
+        compile_project_esm(&dir.join(entry), Some(dir), false, "lattish")
+            .expect("compile_project_esm failed")
     }
 
     fn module_js<'a>(mods: &'a [EmittedJsModule], rel: &str) -> &'a str {
@@ -554,6 +558,7 @@ fn factory() {
             &base.join("app/src/main.tish"),
             Some(&base.join("app")),
             false,
+            "lattish",
         )
         .expect("compile_project_esm failed for sibling dep");
         let rels: Vec<String> = mods
@@ -604,7 +609,7 @@ fn factory() {
             "import { ping } from \"pkg\"\nconsole.log(ping())\n",
         )
         .unwrap();
-        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false)
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false, "lattish")
             .expect("compile_project_esm failed for node_modules dep");
         let rels: Vec<String> = mods
             .iter()
@@ -632,11 +637,343 @@ fn factory() {
         let dir = tmp.path();
         let p = dir.join("main.tish");
         std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
-        let err = compile_project_esm(&p, Some(dir), false).unwrap_err();
+        let err = compile_project_esm(&p, Some(dir), false, "lattish").unwrap_err();
         assert!(
             err.message.contains("Native module import") && err.message.contains("esm"),
             "expected a native-import rejection for ESM, got: {}",
             err.message
         );
     }
+
+    // ── #284: single-module compile for Vite dev (in-graph HMR) ───────────────────────────────
+
+    /// Write `modules` into a fresh temp dir and compile just `entry` (no graph resolution),
+    /// in Vite-dev import-rewrite mode without a source map.
+    fn build_module_vite(entry: &str, modules: &[(&str, &str)]) -> String {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        for (rel, src) in modules {
+            let p = dir.join(rel);
+            if let Some(parent) = p.parent() {
+                std::fs::create_dir_all(parent).unwrap();
+            }
+            let mut f = std::fs::File::create(&p).unwrap();
+            f.write_all(src.as_bytes()).unwrap();
+            f.sync_all().unwrap();
+        }
+        compile_module_esm(
+            &dir.join(entry),
+            Some(dir),
+            false,
+            ImportRewrite::ViteDev,
+            false,
+            "lattish",
+        )
+        .expect("compile_module_esm failed")
+        .js
+    }
+
+    #[test]
+    fn compile_module_esm_vite_preserves_relative_tish_imports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "Vite dev keeps the .tish specifier so resolveId re-enters the plugin:\n{js}"
+        );
+        assert!(
+            !js.contains("./dep.js"),
+            "Vite dev must NOT rewrite .tish to .js:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_leaves_bare_specifiers_unchanged() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h } from \"lattish\"\nconsole.log(h)\n",
+            )],
+        );
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "bare specifier passes through for normal Node/Vite resolution:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_emits_exports() {
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "export const VERSION = \"1.0\"\nexport fn greet(n) { return \"hi \" + n }\nexport default greet\n",
+            )],
+        );
+        assert!(js.contains("export const VERSION = \"1.0\";"), "named const export:\n{js}");
+        assert!(js.contains("export function greet "), "named fn export:\n{js}");
+        assert!(js.contains("export default greet;"), "default export:\n{js}");
+    }
+
+    #[test]
+    fn compile_module_esm_does_not_resolve_graph() {
+        // Compiling a single module must not read or require its dependencies to exist on disk:
+        // only the entry file is created, yet the import to a missing `./dep.tish` compiles fine.
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { id } from \"./dep.tish\"\nconsole.log(id(1))\n",
+            )],
+        );
+        assert!(
+            js.contains("import { id } from \"./dep.tish\";"),
+            "single-module compile emits the import without loading the dependency:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_rejects_native_imports() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "import { readFile } from \"fs\"\nconsole.log(1)\n").unwrap();
+        let err = compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false, "lattish")
+            .unwrap_err();
+        assert!(
+            err.message.contains("Native module import"),
+            "expected a native-import rejection, got: {}",
+            err.message
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_maps_statement_to_tish_file() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "export fn greet(n) { return \"hi \" + n }\nconsole.log(greet(\"x\"))\n")
+            .unwrap();
+        let bundle =
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true, "lattish")
+                .unwrap();
+        let map = bundle
+            .source_map_json
+            .expect("source map requested → must be present");
+        assert!(
+            map.contains("\"version\":3") || map.contains("\"version\": 3"),
+            "v3 source map:\n{map}"
+        );
+        assert!(
+            map.contains("main.tish"),
+            "map sources reference the .tish file:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_embeds_sources_content() {
+        // The map must carry sourcesContent so Vite/devtools never resolve `sources` from disk
+        // (otherwise Vite warns "Sourcemap ... points to missing source files").
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        let src = "export fn greet(n) { return \"hi \" + n }\n";
+        std::fs::write(&p, src).unwrap();
+        let bundle =
+            compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, true, "lattish")
+                .unwrap();
+        let map = bundle.source_map_json.expect("source map requested");
+        assert!(
+            map.contains("\"sourcesContent\""),
+            "map must include a sourcesContent field:\n{map}"
+        );
+        assert!(
+            map.contains("export fn greet"),
+            "sourcesContent must embed the original .tish source:\n{map}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_source_map_requires_no_optimize() {
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "console.log(1)\n").unwrap();
+        let err = compile_module_esm(&p, Some(dir), true, ImportRewrite::ViteDev, true, "lattish")
+            .unwrap_err();
+        assert!(
+            err.message.to_lowercase().contains("optimiz"),
+            "source map + optimize must be rejected, got: {}",
+            err.message
+        );
+    }
+
+    // ── #291: JSX runtime auto-import (h / Fragment) for per-module ESM ────────────────────────
+
+    #[test]
+    fn compile_module_esm_jsx_auto_imports_h() {
+        // A module that uses a JSX element but never imports `h` must get the runtime auto-imported,
+        // or it throws `ReferenceError: h` at load in per-module ESM (issue #291).
+        let js = build_module_vite("main.tish", &[("main.tish", "fn X() { return <div/> }\n")]);
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "JSX element module must auto-import h:\n{js}"
+        );
+        assert!(
+            !js.contains("Fragment"),
+            "no fragment used → Fragment must not be imported:\n{js}"
+        );
+        assert!(js.contains("h(\"div\""), "JSX still lowers to h(...):\n{js}");
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_auto_imports_fragment() {
+        // A fragment lowers to `h(Fragment, …)`, so both `h` and `Fragment` must be auto-imported.
+        let js = build_module_vite(
+            "main.tish",
+            &[("main.tish", "fn X() { return <>{\"a\"}</> }\n")],
+        );
+        assert!(
+            js.contains("import { h, Fragment } from \"lattish\";"),
+            "fragment module must auto-import both h and Fragment:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_skips_import_when_present() {
+        // An explicit `import { h, Fragment } from "lattish"` must not be duplicated.
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h, Fragment } from \"lattish\"\nfn X() { return <></> }\n",
+            )],
+        );
+        assert_eq!(
+            js.matches("from \"lattish\"").count(),
+            1,
+            "exactly one lattish import (the author's), no auto-import duplicate:\n{js}"
+        );
+        assert!(
+            js.contains("import { h, Fragment } from \"lattish\";"),
+            "the author's import is preserved:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_partial_import_extends() {
+        // The author imported only `h`; a fragment also needs `Fragment`, so just that one missing
+        // binding is auto-imported (no re-import of `h`).
+        let js = build_module_vite(
+            "main.tish",
+            &[(
+                "main.tish",
+                "import { h } from \"lattish\"\nfn X() { return <></> }\n",
+            )],
+        );
+        assert!(
+            js.contains("import { Fragment } from \"lattish\";"),
+            "only the missing Fragment binding is auto-imported:\n{js}"
+        );
+        assert!(
+            js.contains("import { h } from \"lattish\";"),
+            "the author's h import is preserved:\n{js}"
+        );
+        assert!(
+            !js.contains("import { h, Fragment }"),
+            "h must not be re-imported alongside Fragment:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_vite_dev_jsx_keeps_bare_runtime_import() {
+        // In Vite-dev mode the auto-import specifier stays the bare package so Node/Vite resolves it
+        // (it is NOT rewritten to a relative `.js` path the way disk ESM does).
+        let js = build_module_vite("main.tish", &[("main.tish", "fn X() { return <div/> }\n")]);
+        assert!(
+            js.contains("from \"lattish\";"),
+            "Vite dev keeps the bare runtime specifier:\n{js}"
+        );
+        assert!(
+            !js.contains("lattish.js") && !js.contains("./lattish"),
+            "Vite dev must not rewrite the runtime specifier to a path:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_module_esm_jsx_import_source_is_configurable() {
+        // The runtime package is overridable (e.g. the scoped `@tishlang/lattish`, or a custom runtime).
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let dir = tmp.path();
+        let p = dir.join("main.tish");
+        std::fs::write(&p, "fn X() { return <div/> }\n").unwrap();
+        let js = compile_module_esm(
+            &p,
+            Some(dir),
+            false,
+            ImportRewrite::ViteDev,
+            false,
+            "@tishlang/lattish",
+        )
+        .expect("compile_module_esm failed")
+        .js;
+        assert!(
+            js.contains("import { h } from \"@tishlang/lattish\";"),
+            "custom jsx import source used:\n{js}"
+        );
+    }
+
+    #[test]
+    fn compile_project_esm_jsx_auto_import_per_module() {
+        // Only the module that actually uses JSX gets the runtime import; plain modules are untouched.
+        let tmp = tempfile::tempdir().expect("tempdir");
+        let base = tmp.path();
+        std::fs::create_dir_all(base.join("src")).unwrap();
+        std::fs::create_dir_all(base.join("node_modules/lattish")).unwrap();
+        std::fs::write(
+            base.join("node_modules/lattish/package.json"),
+            "{\"name\":\"lattish\",\"main\":\"index.tish\"}\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("node_modules/lattish/index.tish"),
+            "export fn h(tag, props, children) { return tag }\nexport let Fragment = \"frag\"\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/view.tish"),
+            "export fn V() { return <div/> }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/plain.tish"),
+            "export fn add(a, b) { return a + b }\n",
+        )
+        .unwrap();
+        std::fs::write(
+            base.join("src/main.tish"),
+            "import { V } from \"./view.tish\"\nimport { add } from \"./plain.tish\"\nconsole.log(add(1, 2))\n",
+        )
+        .unwrap();
+        let mods = compile_project_esm(&base.join("src/main.tish"), Some(base), false, "lattish")
+            .expect("compile_project_esm failed");
+        // The runtime isn't imported by any module, so it's not in the graph; the common-ancestor
+        // output base is `src/`, making the emitted paths flat (`view.js`, `plain.js`, `main.js`).
+        let view = module_js(&mods, "view.js");
+        let plain = module_js(&mods, "plain.js");
+        assert!(
+            view.contains("import { h } from") && view.contains("lattish"),
+            "JSX module auto-imports the runtime:\n{view}"
+        );
+        assert!(
+            !plain.contains("import { h }") && !plain.contains("Fragment"),
+            "non-JSX module must not get a runtime import:\n{plain}"
+        );
+    }
 }