@tishlang/tish 2.2.7 → 2.9.0

package/crates/tish_compile/src/lib.rs

@@ -186,6 +186,44 @@ fn factory() {
             "expected outerVar to be inferred as f64 (Copy, no clone needed)"
         );
     }
+
+    /// i32-loop-var lowering: an FNV-style integer/bitwise hash accumulator declared before a `for`
+    /// and reassigned only by `>>> 0`/bitwise ops lives in an `i32` register across the loop — no
+    /// per-op `to_int32(h)`↔`f64` round-trip — with a single `f64` excursion for the `h * C`
+    /// multiply (which exceeds 2^53, so it must round in f64 before `>>> 0`, exactly as V8 does).
+    #[test]
+    fn fnv_accumulator_lowers_to_i32_register() {
+        let src = r#"
+let h = 2166136261
+for (let i = 0; i < 100; i++) {
+  h = h ^ (i & 255)
+  h = (h * 16777619) >>> 0
+  h = ((h << 13) | (h >>> 19)) >>> 0
+}
+let check = h >>> 0
+console.log(check)
+"#;
+        let rust = compile(&parse(src).unwrap()).unwrap();
+        // The accumulator is an i32 register, initialized via the u32 reinterpretation so the
+        // > i32::MAX seed keeps its JS ToInt32 bit-pattern.
+        assert!(
+            rust.contains("let mut h: i32 = (2166136261u32) as i32;"),
+            "expected `h` to be an i32 register seeded via u32 reinterpretation; got:\n{}",
+            rust.lines().filter(|l| l.contains("h")).take(8).collect::<Vec<_>>().join("\n")
+        );
+        // The per-iteration `to_int32(h)` round-trips are gone: `h` is read straight from the
+        // register inside the bitwise chain (no `to_int32(h)` substring referencing the accumulator).
+        assert!(
+            !rust.contains("to_int32(h)"),
+            "expected NO per-op `to_int32(h)` round-trip on the i32 accumulator"
+        );
+        // The only f64 excursion is the multiply, lowered as an unchecked truncation of the
+        // provably-finite product (`h as f64 * 16777619`).
+        assert!(
+            rust.contains(".to_int_unchecked::<i64>()") && rust.contains("16777619"),
+            "expected the `h * 16777619` excursion to lower to an unchecked f64 truncation"
+        );
+    }
 }
 
 #[cfg(test)]

package/crates/tish_compile/src/resolve.rs

@@ -173,7 +173,7 @@ pub fn program_uses_document(program: &Program) -> bool {
                 ArrayElement::Expr(e) | ArrayElement::Spread(e) => expr_uses_document(e),
             }),
             Expr::Object { props, .. } => props.iter().any(|p| match p {
-                ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => expr_uses_document(e),
+                ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => expr_uses_document(e),
             }),
             Expr::Assign { value, .. }
             | Expr::CompoundAssign { value, .. }
@@ -1601,7 +1601,7 @@ fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
         Expr::Object { props, .. } => {
             for p in props {
                 match p {
-                    ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                    ObjectProp::KeyValue(_, e, _) | ObjectProp::Spread(e) => {
                         rewrite_expr_scope(e, active) // key is a property name; value recurses
                     }
                 }
@@ -1819,6 +1819,7 @@ pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram,
                                             name: Arc::from(v.clone()),
                                             span: *span,
                                         },
+                                        *name_span,
                                     ));
                                 }
                                 merge_push(

package/crates/tish_compile/src/types.rs

@@ -13,6 +13,12 @@ pub enum RustType {
     Value,
     /// f64 (for number)
     F64,
+    /// i32 — a `number` local PROVEN to always hold an integer reinterpretable as a JS ToInt32
+    /// bit-pattern, kept in an integer register across a bitwise/hash hot loop (bun/JSC-style)
+    /// instead of round-tripping `f64`↔`i32` on every op. The value is the signed int32
+    /// (= JS `ToInt32`) view; `>>> 0` results are uint32 reinterpreted into this i32. Only the
+    /// codegen's i32-loop-var lowering produces this type — never `from_annotation`.
+    I32,
     /// String (for string)
     String,
     /// bool (for boolean)
@@ -222,6 +228,7 @@ impl RustType {
         match self {
             RustType::Value => "Value".to_string(),
             RustType::F64 => "f64".to_string(),
+            RustType::I32 => "i32".to_string(),
             RustType::String => "String".to_string(),
             RustType::Bool => "bool".to_string(),
             RustType::Unit => "()".to_string(),
@@ -250,6 +257,7 @@ impl RustType {
         match self {
             RustType::Value => "Value::Null".to_string(),
             RustType::F64 => "0.0".to_string(),
+            RustType::I32 => "0i32".to_string(),
             RustType::String => "String::new()".to_string(),
             RustType::Bool => "false".to_string(),
             RustType::Unit => "()".to_string(),
@@ -306,6 +314,12 @@ impl RustType {
                 "match &{} {{ Value::Number(n) => *n, _ => panic!(\"expected number\") }}",
                 value_expr
             ),
+            // A `Value::Number` narrowed to its JS ToInt32 bit-pattern (NaN/±Inf → 0, exactly as
+            // the bitwise/shift path coerces). Only reached for an `I32`-typed binding boundary.
+            RustType::I32 => format!(
+                "match &{} {{ Value::Number(n) => tishlang_runtime::to_int32(*n), _ => panic!(\"expected number\") }}",
+                value_expr
+            ),
             RustType::String => format!(
                 "match &{} {{ Value::String(s) => s.to_string(), _ => panic!(\"expected string\") }}",
                 value_expr
@@ -363,6 +377,9 @@ impl RustType {
             }
             RustType::Value => native_expr.to_string(),
             RustType::F64 => format!("Value::Number({})", native_expr),
+            // The signed int32 view boxes as a JS Number (every i32 is exactly representable in
+            // f64). The uint32 `>>> 0` reinterpretation is applied at the boxing site, not here.
+            RustType::I32 => format!("Value::Number(({}) as f64)", native_expr),
             RustType::String => format!("Value::String({}.clone().into())", native_expr),
             RustType::Bool => format!("Value::Bool({})", native_expr),
             RustType::Unit => "Value::Null".to_string(),

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,32 @@ 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,
+}
+
 struct Codegen {
     output: String,
     indent: usize,
     in_async: bool,
+    emit_mode: EmitMode,
+    /// 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 +47,20 @@ impl Codegen {
             output: String::new(),
             indent: 0,
             in_async: false,
+            emit_mode: EmitMode::Bundle,
+            module_path: PathBuf::new(),
+            project_root: PathBuf::new(),
+        }
+    }
+
+    fn new_esm(module_path: PathBuf, project_root: PathBuf) -> Self {
+        Self {
+            output: String::new(),
+            indent: 0,
+            in_async: false,
+            emit_mode: EmitMode::Esm,
+            module_path,
+            project_root,
         }
     }
 
@@ -398,9 +428,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 { .. } => {}
@@ -487,9 +526,29 @@ impl Codegen {
         }
     }
 
+    /// Is `expr` the `null` literal? Used to lower `x === null` / `x !== null` to JS `== null` /
+    /// `!= null` so the check catches `undefined` too (tish treats a missing/undefined value as
+    /// null on every other backend) — see the StrictEq/StrictNe arms below.
+    fn is_null_literal(expr: &Expr) -> bool {
+        matches!(
+            expr,
+            Expr::Literal {
+                value: Literal::Null,
+                ..
+            }
+        )
+    }
+
     fn emit_expr(&mut self, expr: &Expr) -> Result<String, CompileError> {
         Ok(match expr {
             Expr::Literal { value, .. } => match value {
+                // Rust's `{}` prints non-finite f64 as `inf` / `-inf` / `NaN`; only `NaN` is valid JS.
+                // Emit the JS spellings so a folded `1/0` / `-1/0` doesn't become an undefined `inf`
+                // identifier in the output.
+                Literal::Number(n) if n.is_nan() => "NaN".to_string(),
+                Literal::Number(n) if n.is_infinite() => {
+                    if *n < 0.0 { "-Infinity".to_string() } else { "Infinity".to_string() }
+                }
                 Literal::Number(n) => format!("{}", n),
                 Literal::String(s) => format!("{:?}", s.as_ref()),
                 Literal::Bool(b) => format!("{}", b),
@@ -510,8 +569,26 @@ impl Codegen {
                     BinOp::Pow => "**",
                     BinOp::Eq => "==",
                     BinOp::Ne => "!=",
-                    BinOp::StrictEq => "===",
-                    BinOp::StrictNe => "!==",
+                    // tish has no `undefined`: a missing/absent value reads back as `null`, so
+                    // `x === null` means "is nullish" — exactly how interp/vm/native behave (a
+                    // missing property is null there). In the JS runtime a missing property is
+                    // `undefined`, so lower `=== null` / `!== null` to loose `== null` / `!= null`,
+                    // which match BOTH null and undefined — keeping `=== null` mean the same thing on
+                    // every target. Strict equality between non-null operands is unaffected.
+                    BinOp::StrictEq => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "=="
+                        } else {
+                            "==="
+                        }
+                    }
+                    BinOp::StrictNe => {
+                        if Self::is_null_literal(left) || Self::is_null_literal(right) {
+                            "!="
+                        } else {
+                            "!=="
+                        }
+                    }
                     BinOp::Lt => "<",
                     BinOp::Le => "<=",
                     BinOp::Gt => ">",
@@ -563,6 +640,15 @@ impl Codegen {
                 ..
             } => {
                 let obj = self.emit_expr(object)?;
+                // `255.toString()` is a JS syntax error — the lexer reads `255.` as a float and
+                // then chokes on the method name. Parenthesize a numeric-literal object so member
+                // access / method calls stay valid: `(255).toString()`. (Folded constants reach
+                // codegen as number literals too, so this covers e.g. `(100 * 2).toString()`.)
+                let obj = if matches!(&**object, Expr::Literal { value: Literal::Number(_), .. }) {
+                    format!("({})", obj)
+                } else {
+                    obj
+                };
                 let expr = match prop {
                     MemberProp::Name { name, .. } => {
                         if name.parse::<u32>().is_ok()
@@ -629,7 +715,7 @@ impl Codegen {
                 let parts: Result<Vec<_>, _> = props
                     .iter()
                     .map(|p| match p {
-                        ObjectProp::KeyValue(k, v) => {
+                        ObjectProp::KeyValue(k, v, _) => {
                             let key = k.as_ref();
                             let val = self.emit_expr(v)?;
                             Ok(if key.chars().all(|c| c.is_alphanumeric() || c == '_') {
@@ -650,7 +736,11 @@ impl Codegen {
             }
             Expr::TypeOf { operand, .. } => {
                 let o = self.emit_expr(operand)?;
-                format!("(typeof {})", o)
+                // tish `typeof null` is "null" (interp/vm/native all agree — null is a first-class
+                // type, not JS's `typeof null === "object"` wart). tish has no `undefined`, so any
+                // nullish operand (incl. a JS-runtime `undefined`) maps to "null". Evaluate the
+                // operand once via the arrow arg so side effects don't run twice.
+                format!("((__v) => __v == null ? \"null\" : typeof __v)({})", o)
             }
             Expr::Delete { target, .. } => {
                 // Emit the raw property *reference*, not a value: `emit_expr` wraps Index /
@@ -808,6 +898,172 @@ 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)?;
+        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,
+) -> 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
+            ),
+        });
+    }
+    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).
@@ -936,3 +1192,103 @@ 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());
+        gen.emit_program(&program, None, None)?;
+        out.push(EmittedJsModule {
+            relative_path: rel_js,
+            js: gen.output,
+        });
+    }
+    Ok(out)
+}
+
+/// 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,8 @@ mod error;
 mod tests_jsx;
 
 pub use codegen::{
-    compile_project_with_jsx, compile_project_with_jsx_and_source_map, compile_with_jsx, JsBundle,
+    compile_project_esm, compile_project_with_jsx, compile_project_with_jsx_and_source_map,
+    compile_with_jsx, EmittedJsModule, JsBundle,
 };
 pub use error::CompileError;