@tishlang/tish 2.10.1 → 2.12.0

package/crates/tish/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tishlang"
-version = "2.10.1"
+version = "2.12.0"
 edition = "2021"
 description = "Tish CLI - run, REPL, compile to native"
 license-file = { workspace = 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>,
@@ -594,6 +602,14 @@ pub(crate) struct CompileModuleArgs {
     /// 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,

package/crates/tish/src/main.rs

@@ -137,6 +137,7 @@ fn main() {
                 a.ios_triple.as_deref(),
                 &a.crate_type,
                 &a.format,
+                &a.jsx_import_source,
             )
         }
         Some(Commands::CompileModule(a)) => compile_module(&a),
@@ -544,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!(
@@ -574,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()
@@ -656,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(
@@ -671,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))?;
@@ -753,6 +764,7 @@ fn compile_module(args: &CompileModuleArgs) -> Result<(), String> {
         optimize,
         import_rewrite,
         want_map,
+        &args.jsx_import_source,
     )
     .map_err(|e| format!("{}", e))?;
 
@@ -781,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)
@@ -790,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

@@ -846,6 +846,75 @@ fn test_compile_module_no_source_map_prints_raw_js() {
     );
 }
 
+/// #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")]

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.
@@ -42,6 +46,9 @@ struct Codegen {
     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 {
@@ -63,10 +70,16 @@ impl Codegen {
             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, import_rewrite: ImportRewrite) -> Self {
+    fn new_esm(
+        module_path: PathBuf,
+        project_root: PathBuf,
+        import_rewrite: ImportRewrite,
+        jsx_import_source: String,
+    ) -> Self {
         Self {
             output: String::new(),
             indent: 0,
@@ -75,6 +88,7 @@ impl Codegen {
             import_rewrite,
             module_path,
             project_root,
+            jsx_import_source,
         }
     }
 
@@ -139,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() {
@@ -176,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, .. } => {
@@ -1235,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 })?;
@@ -1274,8 +1318,12 @@ pub fn compile_project_esm(
         } else {
             module.program.clone()
         };
-        let mut gen =
-            Codegen::new_esm(mod_canon.clone(), res_root_canon.clone(), ImportRewrite::Disk);
+        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,
@@ -1297,6 +1345,7 @@ pub fn compile_module_esm(
     optimize: bool,
     import_rewrite: ImportRewrite,
     source_map: bool,
+    jsx_import_source: &str,
 ) -> Result<JsBundle, CompileError> {
     if source_map && optimize {
         return Err(CompileError {
@@ -1324,7 +1373,12 @@ pub fn compile_module_esm(
         .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);
+    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"));

package/crates/tish_compile_js/src/lib.rs

@@ -10,11 +10,14 @@ mod tests_jsx;
 pub use codegen::{
     compile_module_esm, compile_project_esm, compile_project_with_jsx,
     compile_project_with_jsx_and_source_map, compile_with_jsx, EmittedJsModule, ImportRewrite,
-    JsBundle,
+    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

@@ -475,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 {
@@ -557,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
@@ -607,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()
@@ -635,7 +637,7 @@ 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: {}",
@@ -665,6 +667,7 @@ fn factory() {
             false,
             ImportRewrite::ViteDev,
             false,
+            "lattish",
         )
         .expect("compile_module_esm failed")
         .js
@@ -741,7 +744,7 @@ 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_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false)
+        let err = compile_module_esm(&p, Some(dir), false, ImportRewrite::ViteDev, false, "lattish")
             .unwrap_err();
         assert!(
             err.message.contains("Native module import"),
@@ -758,7 +761,8 @@ fn factory() {
         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).unwrap();
+            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");
@@ -782,7 +786,8 @@ fn factory() {
         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).unwrap();
+            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\""),
@@ -800,7 +805,7 @@ fn factory() {
         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)
+        let err = compile_module_esm(&p, Some(dir), true, ImportRewrite::ViteDev, true, "lattish")
             .unwrap_err();
         assert!(
             err.message.to_lowercase().contains("optimiz"),
@@ -808,4 +813,167 @@ fn factory() {
             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}"
+        );
+    }
 }

package/crates/tish_ui/src/jsx.rs

@@ -541,6 +541,256 @@ pub fn program_contains_jsx(program: &tishlang_ast::Program) -> bool {
     program.statements.iter().any(stmt_contains_jsx)
 }
 
+/// Whether the program contains any JSX **fragment** (`<>…</>`). Fragments lower to
+/// `h(Fragment, null, …)`, so they require the `Fragment` runtime binding in addition to `h`.
+pub fn program_contains_jsx_fragment(program: &tishlang_ast::Program) -> bool {
+    program.statements.iter().any(stmt_contains_jsx_fragment)
+}
+
+/// Which JSX runtime bindings (`h`, `Fragment`) a module needs auto-imported, given which names are
+/// already in module scope. Any JSX needs `h`; fragments additionally need `Fragment`. A binding is
+/// omitted if it's already provided by a top-level import/declaration (see
+/// [`collect_jsx_runtime_bindings_in_scope`]).
+///
+/// Returns a subset of `["h", "Fragment"]` (in that order), or `[]` when the module has no JSX.
+pub fn jsx_runtime_imports_needed(program: &tishlang_ast::Program) -> Vec<&'static str> {
+    if !program_contains_jsx(program) {
+        return Vec::new();
+    }
+    let in_scope = collect_jsx_runtime_bindings_in_scope(program);
+    let mut needed = Vec::new();
+    if !in_scope.contains("h") {
+        needed.push("h");
+    }
+    if program_contains_jsx_fragment(program) && !in_scope.contains("Fragment") {
+        needed.push("Fragment");
+    }
+    needed
+}
+
+/// Top-level names that already bind the JSX runtime symbols `h` / `Fragment`, so the auto-import
+/// must not shadow or duplicate them. Covers named imports (local alias), top-level `const`/`let`,
+/// and `fn` declarations, including those wrapped in `export`.
+pub fn collect_jsx_runtime_bindings_in_scope(program: &tishlang_ast::Program) -> HashSet<String> {
+    use tishlang_ast::{ExportDeclaration, ImportSpecifier, Statement};
+    let mut names = HashSet::new();
+    let note = |n: &str, names: &mut HashSet<String>| {
+        if n == "h" || n == "Fragment" {
+            names.insert(n.to_string());
+        }
+    };
+    for stmt in &program.statements {
+        match stmt {
+            Statement::Import { specifiers, .. } => {
+                for s in specifiers {
+                    if let ImportSpecifier::Named { name, alias, .. } = s {
+                        let local = alias.as_deref().unwrap_or(name.as_ref());
+                        note(local, &mut names);
+                    }
+                }
+            }
+            Statement::VarDecl { name, .. } | Statement::FunDecl { name, .. } => {
+                note(name.as_ref(), &mut names)
+            }
+            Statement::Export { declaration, .. } => {
+                if let ExportDeclaration::Named(inner) = declaration.as_ref() {
+                    match inner.as_ref() {
+                        Statement::VarDecl { name, .. } | Statement::FunDecl { name, .. } => {
+                            note(name.as_ref(), &mut names)
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    names
+}
+
+fn stmt_contains_jsx_fragment(stmt: &tishlang_ast::Statement) -> bool {
+    use tishlang_ast::{ExportDeclaration, Statement};
+    match stmt {
+        Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+            statements.iter().any(stmt_contains_jsx_fragment)
+        }
+        Statement::VarDecl { init, .. } => init.as_ref().is_some_and(expr_contains_jsx_fragment),
+        Statement::VarDeclDestructure { init, .. } => expr_contains_jsx_fragment(init),
+        Statement::ExprStmt { expr, .. } => expr_contains_jsx_fragment(expr),
+        Statement::Return { value, .. } => value.as_ref().is_some_and(expr_contains_jsx_fragment),
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            expr_contains_jsx_fragment(cond)
+                || stmt_contains_jsx_fragment(then_branch)
+                || else_branch
+                    .as_ref()
+                    .is_some_and(|s| stmt_contains_jsx_fragment(s))
+        }
+        Statement::While { cond, body, .. } | Statement::DoWhile { body, cond, .. } => {
+            expr_contains_jsx_fragment(cond) || stmt_contains_jsx_fragment(body)
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
+            init.as_ref().is_some_and(|s| stmt_contains_jsx_fragment(s))
+                || cond.as_ref().is_some_and(expr_contains_jsx_fragment)
+                || update.as_ref().is_some_and(expr_contains_jsx_fragment)
+                || stmt_contains_jsx_fragment(body)
+        }
+        Statement::ForOf { iterable, body, .. } => {
+            expr_contains_jsx_fragment(iterable) || stmt_contains_jsx_fragment(body)
+        }
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
+            expr_contains_jsx_fragment(expr)
+                || cases.iter().any(|(e, ss)| {
+                    e.as_ref().is_some_and(expr_contains_jsx_fragment)
+                        || ss.iter().any(stmt_contains_jsx_fragment)
+                })
+                || default_body
+                    .as_ref()
+                    .is_some_and(|ss| ss.iter().any(stmt_contains_jsx_fragment))
+        }
+        Statement::Try {
+            body,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            stmt_contains_jsx_fragment(body)
+                || catch_body
+                    .as_ref()
+                    .is_some_and(|s| stmt_contains_jsx_fragment(s))
+                || finally_body
+                    .as_ref()
+                    .is_some_and(|s| stmt_contains_jsx_fragment(s))
+        }
+        Statement::FunDecl { body, .. } => stmt_contains_jsx_fragment(body),
+        Statement::Throw { value, .. } => expr_contains_jsx_fragment(value),
+        Statement::Export { declaration, .. } => match declaration.as_ref() {
+            ExportDeclaration::Named(inner) => stmt_contains_jsx_fragment(inner),
+            ExportDeclaration::Default(e) => expr_contains_jsx_fragment(e),
+        },
+        Statement::Import { .. }
+        | Statement::Break { .. }
+        | Statement::Continue { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => false,
+    }
+}
+
+fn expr_contains_jsx_fragment(expr: &Expr) -> bool {
+    match expr {
+        Expr::JsxFragment { .. } => true,
+        Expr::JsxElement {
+            props, children, ..
+        } => {
+            props.iter().any(|p| match p {
+                JsxProp::Attr {
+                    value: JsxAttrValue::Expr(e),
+                    ..
+                }
+                | JsxProp::Spread(e) => expr_contains_jsx_fragment(e),
+                _ => false,
+            }) || children.iter().any(|c| match c {
+                JsxChild::Expr(e) => expr_contains_jsx_fragment(e),
+                JsxChild::Text(_) => false,
+            })
+        }
+        Expr::Binary { left, right, .. } => {
+            expr_contains_jsx_fragment(left) || expr_contains_jsx_fragment(right)
+        }
+        Expr::Unary { operand, .. } => expr_contains_jsx_fragment(operand),
+        Expr::Assign { value, .. } => expr_contains_jsx_fragment(value),
+        Expr::Call { callee, args, .. } => {
+            expr_contains_jsx_fragment(callee)
+                || args.iter().any(|a| match a {
+                    tishlang_ast::CallArg::Expr(e) | tishlang_ast::CallArg::Spread(e) => {
+                        expr_contains_jsx_fragment(e)
+                    }
+                })
+        }
+        Expr::Member { object, prop, .. } => {
+            expr_contains_jsx_fragment(object)
+                || matches!(prop, tishlang_ast::MemberProp::Expr(e) if expr_contains_jsx_fragment(e))
+        }
+        Expr::Index { object, index, .. } => {
+            expr_contains_jsx_fragment(object) || expr_contains_jsx_fragment(index)
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            expr_contains_jsx_fragment(cond)
+                || expr_contains_jsx_fragment(then_branch)
+                || expr_contains_jsx_fragment(else_branch)
+        }
+        Expr::Array { elements, .. } => elements.iter().any(|el| match el {
+            ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_contains_jsx_fragment(e),
+        }),
+        Expr::Object { props, .. } => props.iter().any(|p| match p {
+            ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => expr_contains_jsx_fragment(e),
+        }),
+        Expr::ArrowFunction { body, .. } => match body {
+            tishlang_ast::ArrowBody::Expr(e) => expr_contains_jsx_fragment(e),
+            tishlang_ast::ArrowBody::Block(s) => stmt_contains_jsx_fragment(s),
+        },
+        Expr::NullishCoalesce { left, right, .. } => {
+            expr_contains_jsx_fragment(left) || expr_contains_jsx_fragment(right)
+        }
+        Expr::TemplateLiteral { exprs, .. } => exprs.iter().any(expr_contains_jsx_fragment),
+        Expr::Await { operand, .. } => expr_contains_jsx_fragment(operand),
+        Expr::TypeOf { operand, .. } => expr_contains_jsx_fragment(operand),
+        Expr::Delete { target, .. } => expr_contains_jsx_fragment(target),
+        Expr::CompoundAssign { value, .. } | Expr::LogicalAssign { value, .. } => {
+            expr_contains_jsx_fragment(value)
+        }
+        Expr::MemberAssign { object, value, .. } => {
+            expr_contains_jsx_fragment(object) || expr_contains_jsx_fragment(value)
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            expr_contains_jsx_fragment(object)
+                || expr_contains_jsx_fragment(index)
+                || expr_contains_jsx_fragment(value)
+        }
+        Expr::New { callee, args, .. } => {
+            expr_contains_jsx_fragment(callee)
+                || args.iter().any(|a| match a {
+                    tishlang_ast::CallArg::Expr(e) | tishlang_ast::CallArg::Spread(e) => {
+                        expr_contains_jsx_fragment(e)
+                    }
+                })
+        }
+        Expr::PostfixInc { .. }
+        | Expr::PrefixInc { .. }
+        | Expr::PostfixDec { .. }
+        | Expr::PrefixDec { .. }
+        | Expr::Literal { .. }
+        | Expr::Ident { .. }
+        | Expr::NativeModuleLoad { .. } => false,
+    }
+}
+
 fn stmt_contains_jsx(stmt: &tishlang_ast::Statement) -> bool {
     use tishlang_ast::{ExportDeclaration, Statement};
     match stmt {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tishlang/tish",
-  "version": "2.10.1",
+  "version": "2.12.0",
   "description": "Tish - minimal TS/JS-compatible language. Run, REPL, build to native or other targets.",
   "license": "PIF",
   "repository": {