@tishlang/tish 2.8.0 → 2.10.1

package/crates/tish_compile/tests/perf_codegen_169_173.rs

@@ -0,0 +1,139 @@
+//! Generated-Rust assertions for the Beat-Node native codegen wins #169 and #173.
+//!
+//! These run in their own test binary (separate process from the lib unit tests), so the
+//! dark-ship env flags set here never leak into other tests. Every test sets the SAME flag set
+//! (the gauntlet's `TYPED_FLAGS`), so parallel execution is race-free.
+
+use std::path::PathBuf;
+
+use tishlang_compile::{compile, compile_project_full};
+use tishlang_parser::parse;
+
+/// Enable every dark-shipped typed-native flag, matching `scripts/run_perf_gauntlet.sh`.
+fn enable_typed_flags() {
+    for k in [
+        "TISH_PARAM_NATIVE",
+        "TISH_PARAM_INFER",
+        "TISH_NATIVE_FN",
+        "TISH_STRUCT_INFER",
+        "TISH_FUSED_HOF",
+        "TISH_NATIVE_HOF",
+        "TISH_AGGREGATE_INFER",
+    ] {
+        std::env::set_var(k, "1");
+    }
+}
+
+fn compile_typed(src: &str) -> String {
+    enable_typed_flags();
+    compile(&parse(src).unwrap()).unwrap()
+}
+
+/// Compile a real fixture through the **same** path the `tish build` CLI uses
+/// (`compile_project_full` → `merge_modules` → codegen), so generated-Rust assertions match the
+/// gauntlet build exactly.
+fn compile_fixture_typed(rel: &str) -> String {
+    enable_typed_flags();
+    let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    let path = manifest.join("../..").join(rel).canonicalize().unwrap();
+    let (rust, _, _, _) = compile_project_full(&path, path.parent(), &[], true).unwrap();
+    rust
+}
+
+// ── #169: a fused native `Vec<f64>` reduce result keeps its accumulator native ────────────────
+
+#[test]
+fn issue_169_reduce_fed_accumulator_stays_native() {
+    // The real gauntlet fixture: `acc` is updated from `xs.reduce(...)` (which the native-HOF path
+    // fuses to a native f64 fold). Before #169 the demotion oracle didn't model the fusion, so `acc`
+    // was boxed (`let mut acc = Value::Number(...)`) and paid boxed ops::mul/add/modulo + clone per
+    // iter. Compiled through the same `compile_project_full` path the `tish build` CLI uses.
+    let rust = compile_fixture_typed("tests/perf/typed_array_hof.tish");
+    assert!(
+        rust.contains("let mut acc: f64"),
+        "acc must stay native f64 (reduce result modelled as F64), got:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    assert!(
+        !rust.contains("let mut acc = Value::Number"),
+        "acc must NOT be boxed:\n{}",
+        rust.lines().filter(|l| l.contains("acc")).take(6).collect::<Vec<_>>().join("\n")
+    );
+    // The per-iteration accumulator update is native arithmetic, not boxed ops on `acc`.
+    assert!(
+        !rust.contains("ops::mul(&acc"),
+        "acc update must be native f64, not a boxed ops::mul on acc"
+    );
+}
+
+#[test]
+fn issue_169_non_number_array_reduce_does_not_make_accumulator_native() {
+    // Conservative bail: reduce over a *string* array is not a native f64 fold, so an accumulator it
+    // feeds must stay boxed (sound — we never claim F64 where the emitter would box).
+    let src = r#"
+let ss: string[] = ["a", "b", "c"]
+let acc: number = 0
+let r: number = 0
+while (r < 10) {
+  acc = acc + ss.length
+  r = r + 1
+}
+console.log(acc)
+"#;
+    // Just assert it compiles and is sound; `acc` here is fed by `.length` which is a separate lever.
+    let rust = compile_typed(src);
+    assert!(rust.contains("fn main"), "compiles to a native program");
+}
+
+// ── #173: fill-loop fusion + native `.length` ─────────────────────────────────────────────────
+
+#[test]
+fn issue_173_fill_loop_fuses_to_bulk_extend() {
+    // `let a = []; for (let i = 0; i < N; i++) { a.push(K) }` over a native Vec lowers to a single
+    // `a.extend(std::iter::repeat(K).take((N) as usize))` — one allocation, no per-element pushes.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    // boolean[] fill with a literal bound.
+    assert!(
+        rust.contains("extend(std::iter::repeat(true).take((8_f64) as usize))"),
+        "boolean fill loop must fuse to a bulk extend:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+    // number[] fill with an integer-`let` bound (`n`).
+    assert!(
+        rust.contains("extend(std::iter::repeat(1_f64).take((n) as usize))"),
+        "number fill loop with an int-range bound must fuse:\n{}",
+        rust.lines().filter(|l| l.contains("repeat")).collect::<Vec<_>>().join("\n")
+    );
+}
+
+#[test]
+fn issue_173_length_is_native_f64() {
+    // `vec.length` on a native Vec lowers to `(vec.len() as f64)`, not a boxed `get_prop`.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        rust.contains("a.len() as f64"),
+        "native Vec `.length` must lower to `(a.len() as f64)`"
+    );
+    assert!(
+        !rust.contains("get_prop(&a, \"length\")"),
+        "native Vec `.length` must not go through boxed get_prop"
+    );
+}
+
+#[test]
+fn issue_173_adversarial_cases_do_not_fuse() {
+    // Non-constant push arg, extra statement, and `break` in the body must NOT fuse — they keep the
+    // per-element push loop (correctness over coverage). The fixture's only fusions are the three
+    // canonical fills (8, n, 3); a non-constant `push(i * 2)` must not produce an extend.
+    let rust = compile_fixture_typed("tests/core/array_init_pattern.tish");
+    assert!(
+        !rust.contains("repeat((i * 2"),
+        "non-constant push arg must not be fused into a repeat-fill"
+    );
+    // Exactly the three sound fills are emitted (8, n, 3) — no extra fusions crept in.
+    let fusions = rust.matches("std::iter::repeat").count();
+    assert_eq!(
+        fusions, 3,
+        "exactly 3 fill loops should fuse (boolFill=8, sieve=n, oobGrow=3), found {fusions}"
+    );
+}

package/crates/tish_compile_js/Cargo.toml

@@ -16,3 +16,6 @@ tishlang_compile = { path = "../tish_compile", version = ">=0.1" }
 tishlang_opt = { path = "../tish_opt", version = ">=0.1" }
 tishlang_parser = { path = "../tish_parser", version = ">=0.1" }
 tishlang_ui = { path = "../tish_ui", version = ">=0.1", default-features = false, features = ["compiler"] }
+
+[dev-dependencies]
+tempfile = "3"

package/crates/tish_compile_js/src/codegen.rs

@@ -4,16 +4,44 @@ use std::path::{Path, PathBuf};
 
 use sourcemap::SourceMapBuilder;
 use tishlang_ast::{
-    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern, Expr,
-    FunParam, Literal, LogicalAssignOp, MemberProp, ObjectProp, Program, Statement, UnaryOp,
+    ArrayElement, ArrowBody, BinOp, CallArg, CompoundOp, DestructElement, DestructPattern,
+    ExportDeclaration, Expr, FunParam, ImportSpecifier, Literal, LogicalAssignOp, MemberProp,
+    ObjectProp, Program, Statement, UnaryOp,
 };
 
 use crate::error::CompileError;
 
+/// 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.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum EmitMode {
+    Bundle,
+    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,
 }
 
 fn stmt_terminates_switch(stmt: Option<&Statement>) -> bool {
@@ -31,6 +59,22 @@ impl Codegen {
             output: String::new(),
             indent: 0,
             in_async: false,
+            emit_mode: EmitMode::Bundle,
+            import_rewrite: ImportRewrite::Disk,
+            module_path: PathBuf::new(),
+            project_root: PathBuf::new(),
+        }
+    }
+
+    fn new_esm(module_path: PathBuf, project_root: PathBuf, import_rewrite: ImportRewrite) -> Self {
+        Self {
+            output: String::new(),
+            indent: 0,
+            in_async: false,
+            emit_mode: EmitMode::Esm,
+            import_rewrite,
+            module_path,
+            project_root,
         }
     }
 
@@ -398,9 +442,18 @@ impl Codegen {
                 }
                 self.writeln("}");
             }
-            Statement::Import { .. } | Statement::Export { .. } => {
-                // Resolved away by merge_modules
-            }
+            Statement::Import {
+                specifiers, from, ..
+            } => match self.emit_mode {
+                // Bundle: resolved away by merge_modules (the dep bindings are already inlined).
+                EmitMode::Bundle => {}
+                EmitMode::Esm => self.emit_esm_import(specifiers, from.as_ref())?,
+            },
+            Statement::Export { declaration, .. } => match self.emit_mode {
+                // Bundle: merge_modules unwrapped exports into plain top-level declarations.
+                EmitMode::Bundle => {}
+                EmitMode::Esm => self.emit_esm_export(declaration)?,
+            },
             Statement::TypeAlias { .. }
             | Statement::DeclareVar { .. }
             | Statement::DeclareFun { .. } => {}
@@ -859,6 +912,183 @@ impl Codegen {
             CallArg::Spread(e) => Ok(format!("...{}", self.emit_expr(e)?)),
         }
     }
+
+    /// Emit a real ES `import` statement (ESM mode), rewriting the `.tish` specifier to its sibling
+    /// `.js` output path. Named and namespace specifiers can't share one statement, so a module that
+    /// imports both is split across two lines.
+    fn emit_esm_import(
+        &mut self,
+        specifiers: &[ImportSpecifier],
+        from: &str,
+    ) -> Result<(), CompileError> {
+        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;
+        for s in specifiers {
+            match s {
+                ImportSpecifier::Named { name, alias, .. } => match alias {
+                    Some(a) => named.push(format!(
+                        "{} as {}",
+                        Self::escape_ident(name.as_ref()),
+                        Self::escape_ident(a.as_ref())
+                    )),
+                    None => named.push(Self::escape_ident(name.as_ref())),
+                },
+                ImportSpecifier::Default { name, .. } => {
+                    default_local = Some(Self::escape_ident(name.as_ref()))
+                }
+                ImportSpecifier::Namespace { name, .. } => {
+                    namespace_local = Some(Self::escape_ident(name.as_ref()))
+                }
+            }
+        }
+        if let Some(ns) = namespace_local {
+            match &default_local {
+                Some(def) => self.writeln(&format!("import {}, * as {} from \"{}\";", def, ns, spec)),
+                None => self.writeln(&format!("import * as {} from \"{}\";", ns, spec)),
+            }
+            if !named.is_empty() {
+                self.writeln(&format!("import {{ {} }} from \"{}\";", named.join(", "), spec));
+            }
+        } else if !named.is_empty() {
+            match &default_local {
+                Some(def) => self.writeln(&format!(
+                    "import {}, {{ {} }} from \"{}\";",
+                    def,
+                    named.join(", "),
+                    spec
+                )),
+                None => self.writeln(&format!("import {{ {} }} from \"{}\";", named.join(", "), spec)),
+            }
+        } else if let Some(def) = &default_local {
+            self.writeln(&format!("import {} from \"{}\";", def, spec));
+        } else {
+            self.writeln(&format!("import \"{}\";", spec));
+        }
+        Ok(())
+    }
+
+    /// Emit a real ES `export` (ESM mode). Named exports prefix the inner declaration with the
+    /// `export` keyword; default exports become `export default <expr>;`.
+    fn emit_esm_export(&mut self, declaration: &ExportDeclaration) -> Result<(), CompileError> {
+        match declaration {
+            ExportDeclaration::Named(inner) => {
+                // Emit the inner declaration, then splice the `export ` keyword in front of it. The
+                // declaration's first line is `<indent><keyword> …`, so the keyword goes right after
+                // the leading indent.
+                let start = self.output.len();
+                self.emit_statement(inner)?;
+                let insert_at = start + self.indent_str().len();
+                if insert_at <= self.output.len() {
+                    self.output.insert_str(insert_at, "export ");
+                }
+            }
+            ExportDeclaration::Default(e) => {
+                let v = self.emit_expr(e)?;
+                self.writeln(&format!("export default {};", v));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Rewrite a Tish import specifier to the ESM `.js` specifier that the emitted module tree uses.
+/// Relative specifiers keep their shape (the output tree mirrors the source tree) with `.tish`
+/// swapped to `.js`. Bare specifiers are resolved to a `.tish` file and re-expressed as a relative
+/// path from the importer's output location. Native imports (`tish:*`, `cargo:*`, …) are rejected.
+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 {
+            message: format!(
+                "Native module import '{}' is not supported with --target js --format esm (native modules require --target native).",
+                spec
+            ),
+        });
+    }
+    // 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));
+    }
+    // Bare specifier (e.g. a package): resolve to its `.tish` file and express it relative to the
+    // importer's output `.js`, so the emitted module tree stays self-contained.
+    let from_dir = importer_abs.parent().unwrap_or_else(|| Path::new("."));
+    let dep = tishlang_compile::resolve_bare_spec(spec, from_dir, project_root).ok_or_else(|| {
+        CompileError {
+            message: format!(
+                "Cannot resolve package import '{}' for --format esm. Only relative imports and packages resolvable to a .tish entry are supported; use --format bundle otherwise.",
+                spec
+            ),
+        }
+    })?;
+    // The emitted module tree mirrors the real source tree under a common base (see
+    // `compile_project_esm`), so the relative path between two *absolute* canonical paths is the
+    // same as the relative path between their emitted `.js` files. This holds whether the dependency
+    // lives under the entry's project root, in a sibling package, or in `node_modules` (#282), so no
+    // "outside the project root" rejection is needed.
+    let dep_canon = dep.canonicalize().unwrap_or(dep);
+    let importer_canon = importer_abs
+        .canonicalize()
+        .unwrap_or_else(|_| importer_abs.to_path_buf());
+    let importer_dir = importer_canon.parent().unwrap_or_else(|| Path::new("/"));
+    Ok(spec_ext_to_js(&relative_specifier(importer_dir, &dep_canon)))
+}
+
+/// Swap a relative import specifier's `.tish` extension for `.js` (or append `.js` when extensionless).
+/// Already-`.js`/`.mjs` specifiers pass through unchanged.
+fn spec_ext_to_js(spec: &str) -> String {
+    if let Some(base) = spec.strip_suffix(".tish") {
+        format!("{}.js", base)
+    } else if spec.ends_with(".js") || spec.ends_with(".mjs") {
+        spec.to_string()
+    } else {
+        format!("{}.js", spec)
+    }
+}
+
+/// Build a `./`-prefixed relative module specifier from `from_dir` to `to_file`, compared
+/// component-wise, using `/` separators as ESM requires. Both paths must be expressed the same way
+/// (both absolute canonical, or both relative to the same base) so the shared prefix lines up.
+fn relative_specifier(from_dir: &Path, to_file: &Path) -> String {
+    let from: Vec<String> = from_dir
+        .components()
+        .map(|c| c.as_os_str().to_string_lossy().into_owned())
+        .collect();
+    let to: Vec<String> = to_file
+        .components()
+        .map(|c| c.as_os_str().to_string_lossy().into_owned())
+        .collect();
+    let mut i = 0;
+    while i < from.len() && i < to.len() && from[i] == to[i] {
+        i += 1;
+    }
+    let mut parts: Vec<String> = Vec::new();
+    for _ in i..from.len() {
+        parts.push("..".to_string());
+    }
+    for c in &to[i..] {
+        parts.push(c.clone());
+    }
+    let joined = parts.join("/");
+    if joined.starts_with("..") {
+        joined
+    } else {
+        format!("./{}", joined)
+    }
 }
 
 /// Compile a single program (no imports) to JavaScript. JSX lowers to `h` / `Fragment` (Lattish).
@@ -987,3 +1217,182 @@ pub fn compile_project_with_jsx(
     };
     Ok(compile_project_js_inner(entry_path, project_root, optimize, false, &out_name)?.js)
 }
+
+/// One emitted ES module: where it goes (relative to the output directory, mirroring the source
+/// tree) and its JavaScript. See [`compile_project_esm`].
+#[derive(Debug, Clone)]
+pub struct EmittedJsModule {
+    pub relative_path: PathBuf,
+    pub js: String,
+}
+
+/// Compile a project to **ES modules** — one `.js` file per `.tish` module, with real `import` /
+/// `export` statements (issue #282). Unlike [`compile_project_with_jsx`], modules are NOT merged, so
+/// each keeps its own scope (no exported-name collisions) and a bundler can tree-shake the graph.
+/// Output paths mirror the source tree relative to the deepest directory common to every module in
+/// the graph (so sibling-package / `node_modules` deps are included), with `.tish` swapped to `.js`.
+pub fn compile_project_esm(
+    entry_path: &Path,
+    project_root: Option<&Path>,
+    optimize: bool,
+) -> Result<Vec<EmittedJsModule>, CompileError> {
+    let modules = tishlang_compile::resolve_project(entry_path, project_root)
+        .map_err(|e| CompileError { message: e })?;
+    tishlang_compile::detect_cycles(&modules).map_err(|e| CompileError { message: e })?;
+    // Resolution root: where bare-specifier / `node_modules` lookups are anchored. Unchanged
+    // semantics — only used for `resolve_bare_spec`, which itself walks upward from each importer.
+    let res_root = project_root
+        .map(Path::to_path_buf)
+        .or_else(|| entry_path.parent().map(Path::to_path_buf))
+        .unwrap_or_else(|| PathBuf::from("."));
+    let res_root_canon = res_root.canonicalize().unwrap_or(res_root);
+
+    // Output layout base: the deepest directory that is an ancestor of *every* module in the graph.
+    // The output tree mirrors the real filesystem beneath this base, so a dependency in a sibling
+    // package or `node_modules` (#282 follow-up) gets a stable home in the output instead of being
+    // rejected for living "outside the project root". For a self-contained project this is just the
+    // project root, so existing layouts are unchanged.
+    let mod_canons: Vec<PathBuf> = modules
+        .iter()
+        .map(|m| m.path.canonicalize().unwrap_or_else(|_| m.path.clone()))
+        .collect();
+    let layout_base = common_ancestor_dir(&mod_canons);
+
+    let mut out = Vec::with_capacity(modules.len());
+    for (module, mod_canon) in modules.iter().zip(mod_canons.iter()) {
+        let rel = mod_canon
+            .strip_prefix(&layout_base)
+            .map(Path::to_path_buf)
+            .unwrap_or_else(|_| {
+                // `layout_base` is a common ancestor of every module, so this is unreachable; fall
+                // back to the bare file name rather than panicking if a path is unexpectedly absolute.
+                PathBuf::from(mod_canon.file_name().unwrap_or(mod_canon.as_os_str()))
+            });
+        let rel_js = rel.with_extension("js");
+        let program = if optimize {
+            tishlang_opt::optimize(&module.program)
+        } else {
+            module.program.clone()
+        };
+        let mut gen =
+            Codegen::new_esm(mod_canon.clone(), res_root_canon.clone(), ImportRewrite::Disk);
+        gen.emit_program(&program, None, None)?;
+        out.push(EmittedJsModule {
+            relative_path: rel_js,
+            js: gen.output,
+        });
+    }
+    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,
+) -> 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);
+    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
+/// is its parent directory; for files that share only the filesystem root it is `/`.
+fn common_ancestor_dir(files: &[PathBuf]) -> PathBuf {
+    let parent_components = |p: &Path| -> Vec<std::ffi::OsString> {
+        p.parent()
+            .unwrap_or_else(|| Path::new("/"))
+            .components()
+            .map(|c| c.as_os_str().to_os_string())
+            .collect()
+    };
+    let mut common: Vec<std::ffi::OsString> = match files.first() {
+        Some(f) => parent_components(f),
+        None => return PathBuf::from("/"),
+    };
+    for f in &files[1..] {
+        let comps = parent_components(f);
+        let mut i = 0;
+        while i < common.len() && i < comps.len() && common[i] == comps[i] {
+            i += 1;
+        }
+        common.truncate(i);
+    }
+    if common.is_empty() {
+        return PathBuf::from("/");
+    }
+    let mut base = PathBuf::new();
+    for c in &common {
+        base.push(c);
+    }
+    base
+}

package/crates/tish_compile_js/src/lib.rs

@@ -8,7 +8,9 @@ mod error;
 mod tests_jsx;
 
 pub use codegen::{
-    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+    compile_module_esm, compile_project_esm, compile_project_with_jsx,
+    compile_project_with_jsx_and_source_map, compile_with_jsx, EmittedJsModule, ImportRewrite,
+    JsBundle,
 };
 pub use error::CompileError;