@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_compile/src/resolve.rs

@@ -49,6 +49,7 @@ pub struct NativeBuildArtifacts {
 const BUILTIN_ALIASES: &[(&str, &str)] = &[
     ("fs", "tish:fs"),
     ("http", "tish:http"),
+    ("timers", "tish:timers"),
     ("process", "tish:process"),
     ("ws", "tish:ws"),
 ];
@@ -66,14 +67,17 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
 
 /// Built-in modules that come from tishlang_runtime, not from package.json.
 pub fn is_builtin_native_spec(spec: &str) -> bool {
-    matches!(spec, "tish:fs" | "tish:http" | "tish:process" | "tish:ws")
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+    matches!(spec, "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
 /// Built-in modules (tish:fs, tish:http, tish:process) are skipped - they use tishlang_runtime directly.
 /// Handles both lowered `NativeModuleLoad` (merged modules) and raw `import { … } from 'tish:…'`.
-pub fn resolve_native_modules(program: &Program, project_root: &Path) -> Result<Vec<ResolvedNativeModule>, String> {
+pub fn resolve_native_modules(
+    program: &Program,
+    project_root: &Path,
+) -> Result<Vec<ResolvedNativeModule>, String> {
     let root_canon = project_root
         .canonicalize()
         .map_err(|e| format!("Cannot canonicalize project root: {}", e))?;
@@ -131,12 +135,17 @@ pub fn cargo_export_fn_name(spec: &str) -> String {
     out
 }
 
-fn resolve_cargo_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNativeModule, String> {
+fn resolve_cargo_native_module(
+    spec: &str,
+    project_root: &Path,
+) -> Result<ResolvedNativeModule, String> {
     let tail = spec
         .strip_prefix("cargo:")
         .ok_or_else(|| format!("Invalid cargo native spec: {}", spec))?;
     if tail.is_empty() {
-        return Err("cargo: import needs a dependency name, e.g. import { x } from 'cargo:serde_json'".into());
+        return Err(
+            "cargo: import needs a dependency name, e.g. import { x } from 'cargo:my_crate'".into(),
+        );
     }
     let dep_key = tail.to_string();
     let tish = read_project_tish_config(project_root);
@@ -179,14 +188,26 @@ fn resolve_native_module(spec: &str, project_root: &Path) -> Result<ResolvedNati
     let pkg_json = pkg_dir.join("package.json");
     let content = std::fs::read_to_string(&pkg_json)
         .map_err(|e| format!("Cannot read {}: {}", pkg_json.display(), e))?;
-    let json: serde_json::Value =
-        serde_json::from_str(&content).map_err(|e| format!("Invalid JSON in {}: {}", pkg_json.display(), e))?;
+    let json: serde_json::Value = serde_json::from_str(&content)
+        .map_err(|e| format!("Invalid JSON in {}: {}", pkg_json.display(), e))?;
     let tish = json
         .get("tish")
         .and_then(|v| v.as_object())
-        .ok_or_else(|| format!("Package {} has no \"tish\" config in package.json", package_name))?;
-    if !tish.get("module").and_then(|v| v.as_bool()).unwrap_or(false) {
-        return Err(format!("Package {} is not a Tish native module (tish.module must be true)", package_name));
+        .ok_or_else(|| {
+            format!(
+                "Package {} has no \"tish\" config in package.json",
+                package_name
+            )
+        })?;
+    if !tish
+        .get("module")
+        .and_then(|v| v.as_bool())
+        .unwrap_or(false)
+    {
+        return Err(format!(
+            "Package {} is not a Tish native module (tish.module must be true)",
+            package_name
+        ));
     }
     let raw_crate = tish
         .get("crate")
@@ -219,7 +240,9 @@ pub fn read_project_tish_config(project_root: &Path) -> serde_json::Value {
     let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) else {
         return serde_json::json!({});
     };
-    json.get("tish").cloned().unwrap_or_else(|| serde_json::json!({}))
+    json.get("tish")
+        .cloned()
+        .unwrap_or_else(|| serde_json::json!({}))
 }
 
 fn resolve_cargo_path_for_toml(project_root: &Path, raw: &str) -> String {
@@ -233,7 +256,10 @@ fn resolve_cargo_path_for_toml(project_root: &Path, raw: &str) -> String {
     resolved.display().to_string().replace('\\', "/")
 }
 
-fn json_to_cargo_inline_value(v: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+fn json_to_cargo_inline_value(
+    v: &serde_json::Value,
+    project_root: &Path,
+) -> Result<String, String> {
     match v {
         serde_json::Value::String(s) => Ok(format!("{:?}", s.as_str())),
         serde_json::Value::Bool(b) => Ok(b.to_string()),
@@ -264,7 +290,10 @@ fn json_to_cargo_inline_value(v: &serde_json::Value, project_root: &Path) -> Res
 
 /// Serialize `tish.rustDependencies` from project `package.json` into Cargo.toml `[dependencies]` lines.
 /// Relative `path = "…"` entries in inline tables are resolved against `project_root` so the temp build crate can find them.
-pub fn format_rust_dependencies_toml(tish: &serde_json::Value, project_root: &Path) -> Result<String, String> {
+pub fn format_rust_dependencies_toml(
+    tish: &serde_json::Value,
+    project_root: &Path,
+) -> Result<String, String> {
     let Some(obj) = tish.get("rustDependencies").and_then(|v| v.as_object()) else {
         return Ok(String::new());
     };
@@ -313,7 +342,10 @@ pub fn infer_native_module_exports(program: &Program) -> HashMap<String, HashSet
     for stmt in &program.statements {
         match stmt {
             Statement::VarDecl {
-                init: Some(Expr::NativeModuleLoad { spec, export_name, .. }),
+                init:
+                    Some(Expr::NativeModuleLoad {
+                        spec, export_name, ..
+                    }),
                 ..
             } => {
                 let s = spec.as_ref();
@@ -324,8 +356,11 @@ pub fn infer_native_module_exports(program: &Program) -> HashMap<String, HashSet
                     .or_default()
                     .insert(export_name.to_string());
             }
-            Statement::Import { specifiers, from, .. } if is_native_import(from.as_ref()) => {
-                let spec = normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string());
+            Statement::Import {
+                specifiers, from, ..
+            } if is_native_import(from.as_ref()) => {
+                let spec =
+                    normalize_builtin_spec(from.as_ref()).unwrap_or_else(|| from.to_string());
                 if is_builtin_native_spec(&spec) {
                     continue;
                 }
@@ -354,11 +389,15 @@ pub fn generate_native_wrapper_rs(
          use std::cell::RefCell;\n\
          use std::rc::Rc;\n\
          use std::sync::Arc;\n\
-         use tishlang_runtime::{ObjectMap, Value};\n\n",
+         use tishlang_runtime::{ObjectMap, Value, VmRef};\n\n",
     );
     let mut any = false;
     for m in modules {
-        let Some(NativeModuleInit::Generated { shim_crate, export_fn }) = init_by_spec.get(&m.spec) else {
+        let Some(NativeModuleInit::Generated {
+            shim_crate,
+            export_fn,
+        }) = init_by_spec.get(&m.spec)
+        else {
             continue;
         };
         let Some(names) = inferred.get(&m.spec) else {
@@ -376,11 +415,11 @@ pub fn generate_native_wrapper_rs(
             let rust_fn = export_name_to_rust_ident(&export_name);
             let key_lit = format!("{:?}", export_name);
             file.push_str(&format!(
-                "    m.insert(Arc::from({}), Value::Function(Rc::new(|args: &[Value]| {{\n        {}::{}(args)\n    }})));\n",
+                "    m.insert(Arc::from({}), Value::native(|args: &[Value]| {{\n        {}::{}(args)\n    }}));\n",
                 key_lit, shim_crate, rust_fn
             ));
         }
-        file.push_str("    Value::Object(Rc::new(RefCell::new(m)))\n}\n\n");
+        file.push_str("    Value::Object(VmRef::new(m))\n}\n\n");
     }
     if !any {
         return String::new();
@@ -405,9 +444,16 @@ pub fn compute_native_build_artifacts(
     let mut native_init: HashMap<String, NativeModuleInit> = HashMap::new();
     for m in native_modules {
         let use_gen = if is_cargo_native_spec(&m.spec) {
-            inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+            inferred
+                .get(&m.spec)
+                .map(|s| !s.is_empty())
+                .unwrap_or(false)
         } else {
-            gen_tish && inferred.get(&m.spec).map(|s| !s.is_empty()).unwrap_or(false)
+            gen_tish
+                && inferred
+                    .get(&m.spec)
+                    .map(|s| !s.is_empty())
+                    .unwrap_or(false)
         };
         let init = if use_gen {
             NativeModuleInit::Generated {
@@ -538,13 +584,18 @@ pub fn resolve_project(
     entry_path: &Path,
     project_root: Option<&Path>,
 ) -> Result<Vec<ResolvedModule>, String> {
-    let project_root = project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
+    let project_root =
+        project_root.unwrap_or_else(|| entry_path.parent().unwrap_or(Path::new(".")));
     let entry_canon = entry_path
         .canonicalize()
         .map_err(|e| format!("Cannot canonicalize entry {}: {}", entry_path.display(), e))?;
-    let root_canon = project_root
-        .canonicalize()
-        .map_err(|e| format!("Cannot canonicalize project root {}: {}", project_root.display(), e))?;
+    let root_canon = project_root.canonicalize().map_err(|e| {
+        format!(
+            "Cannot canonicalize project root {}: {}",
+            project_root.display(),
+            e
+        )
+    })?;
 
     let mut visited = HashSet::new();
     let mut path_to_module: HashMap<PathBuf, Program> = HashMap::new();
@@ -574,21 +625,23 @@ pub fn resolve_project_from_stdin(
     source: &str,
     project_root: &Path,
 ) -> Result<Vec<ResolvedModule>, String> {
-    let root_canon = project_root
-        .canonicalize()
-        .map_err(|e| format!("Cannot canonicalize project root {}: {}", project_root.display(), e))?;
+    let root_canon = project_root.canonicalize().map_err(|e| {
+        format!(
+            "Cannot canonicalize project root {}: {}",
+            project_root.display(),
+            e
+        )
+    })?;
 
     let stdin_path = root_canon.join("<stdin>");
-    let program = tishlang_parser::parse(source)
-        .map_err(|e| format!("Parse error (stdin): {}", e))?;
+    let program =
+        tishlang_parser::parse(source).map_err(|e| format!("Parse error (stdin): {}", e))?;
 
     let mut visited = HashSet::new();
     let mut path_to_module: HashMap<PathBuf, Program> = HashMap::new();
     let mut load_order: Vec<PathBuf> = Vec::new();
 
-    let from_dir = stdin_path
-        .parent()
-        .unwrap_or_else(|| Path::new("."));
+    let from_dir = stdin_path.parent().unwrap_or_else(|| Path::new("."));
 
     for stmt in &program.statements {
         if let Statement::Import { from, .. } = stmt {
@@ -667,7 +720,7 @@ fn load_module_recursive(
 }
 
 /// Returns true for native module imports that don't resolve to files.
-/// - fs, http, process, ws (Node-compatible aliases for tish:fs, tish:http, tish:process, tish:ws)
+/// - fs, http, timers, process, ws (Node-compatible aliases for tish:*)
 /// - tish:egui, tish:polars, etc.
 /// - cargo:… (Cargo `rustDependencies` + generated wrapper; Rust native backend)
 /// - @scope/package (npm-style)
@@ -675,7 +728,7 @@ pub fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
         || spec.starts_with('@')
-        || matches!(spec, "fs" | "http" | "process" | "ws")
+        || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
 /// Map native spec to Cargo feature name for built-in tish:* modules.
@@ -684,30 +737,52 @@ pub fn native_spec_to_feature(spec: &str) -> Option<String> {
     canonical.strip_prefix("tish:").map(|s| s.to_string())
 }
 
-/// Resolve a bare specifier (e.g. "lattish") to a path via node_modules.
-fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
+/// Resolve `package.json` at `pkg_root` to the package's main `.tish` entry, if `name` matches `spec`.
+fn resolve_package_root_to_entry(pkg_root: &Path, spec: &str) -> Option<PathBuf> {
+    let pkg_json = pkg_root.join("package.json");
+    if !pkg_json.exists() {
+        return None;
+    }
+    if read_package_name(&pkg_json).as_deref() != Some(spec) {
+        return None;
+    }
+    let content = std::fs::read_to_string(&pkg_json).ok()?;
+    let json: serde_json::Value = serde_json::from_str(&content).ok()?;
+    let entry = json
+        .get("tish")
+        .and_then(|t| t.get("module"))
+        .and_then(|m| m.as_str())
+        .or_else(|| json.get("main").and_then(|m| m.as_str()))
+        .unwrap_or("index.tish");
+    let entry_clean = entry.trim_start_matches("./");
+    let resolved = pkg_root.join(entry_clean);
+    if !resolved.exists() {
+        return None;
+    }
+    match resolved.canonicalize() {
+        Ok(p) => Some(p),
+        Err(_) => Some(resolved),
+    }
+}
+
+/// Resolve a bare specifier (e.g. "lattish") to the package entry `.tish` file.
+///
+/// Walks upward from `from_dir` and, at each level, checks (same order as native [`find_package_dir`]):
+/// - `node_modules/<spec>/`
+/// - `<spec>/` as a sibling directory (monorepo: `…/tish/tish-candle` next to `…/tish/tish-hub`)
+/// - the search directory itself if its `package.json` name matches `spec`
+pub fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
     let mut search = from_dir.to_path_buf();
     loop {
-        let node_mod = search.join("node_modules").join(spec);
-        let pkg_json = node_mod.join("package.json");
-        if pkg_json.exists() {
-            if let Some(name) = read_package_name(&pkg_json) {
-                if name == spec {
-                    let content = std::fs::read_to_string(&pkg_json).ok()?;
-                    let json: serde_json::Value = serde_json::from_str(&content).ok()?;
-                    let entry = json
-                        .get("tish")
-                        .and_then(|t| t.get("module"))
-                        .and_then(|m| m.as_str())
-                        .or_else(|| json.get("main").and_then(|m| m.as_str()));
-                    let entry = entry.unwrap_or("index.tish");
-                    let entry_clean = entry.trim_start_matches("./");
-                    let resolved = node_mod.join(entry_clean);
-                    if resolved.exists() {
-                        return resolved.canonicalize().ok();
-                    }
-                }
-            }
+        if let Some(p) = resolve_package_root_to_entry(&search.join("node_modules").join(spec), spec)
+        {
+            return Some(p);
+        }
+        if let Some(p) = resolve_package_root_to_entry(&search.join(spec), spec) {
+            return Some(p);
+        }
+        if let Some(p) = resolve_package_root_to_entry(&search, spec) {
+            return Some(p);
         }
         if let Some(parent) = search.parent() {
             if parent == search {
@@ -738,7 +813,7 @@ fn resolve_import_path(
             return Ok(path);
         }
         return Err(format!(
-            "Package '{}' not found in node_modules. Install it with: npm install {}",
+            "Package '{}' not found. Install with `npm install {}`, or place the package under node_modules/ or as a sibling directory (same layout as native `find_package_dir`).",
             spec, spec
         ));
     }
@@ -787,7 +862,10 @@ pub fn detect_cycles(modules: &[ResolvedModule]) -> Result<(), String> {
                 .iter()
                 .map(|&i| modules[i].path.display().to_string())
                 .collect();
-            return Err(format!("Circular import detected: {}", path_names.join(" -> ")));
+            return Err(format!(
+                "Circular import detected: {}",
+                path_names.join(" -> ")
+            ));
         }
     }
     Ok(())
@@ -817,14 +895,8 @@ fn has_cycle_from(
                     stack.push(dep_idx);
                     let dep = &modules[dep_idx];
                     let dep_dir = dep.path.parent().unwrap_or(Path::new("."));
-                    if has_cycle_from(
-                        dep_dir,
-                        &dep.program,
-                        path_to_idx,
-                        modules,
-                        stack,
-                        visiting,
-                    )? {
+                    if has_cycle_from(dep_dir, &dep.program, path_to_idx, modules, stack, visiting)?
+                    {
                         return Ok(true);
                     }
                     stack.pop();
@@ -836,10 +908,27 @@ fn has_cycle_from(
     Ok(false)
 }
 
+/// Result of [`merge_modules`]: merged AST plus, per top-level statement, the originating `.tish` file.
+#[derive(Debug)]
+pub struct MergedProgram {
+    pub program: Program,
+    pub statement_sources: Vec<PathBuf>,
+}
+
+fn merge_push(
+    statements: &mut Vec<Statement>,
+    statement_sources: &mut Vec<PathBuf>,
+    stmt: Statement,
+    source: PathBuf,
+) {
+    statements.push(stmt);
+    statement_sources.push(source);
+}
+
 /// Merge all resolved modules into a single program. Dependencies are emitted first.
 /// Import statements are rewritten as bindings from already-emitted dep exports.
 /// Export statements are unwrapped (the inner declaration is emitted).
-pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
+pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<MergedProgram, String> {
     let path_to_idx: HashMap<PathBuf, usize> = modules
         .iter()
         .enumerate()
@@ -870,45 +959,62 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
     }
 
     let mut statements = Vec::new();
+    let mut statement_sources = Vec::new();
     for (idx, module) in modules.iter().enumerate() {
+        let src_path = module.path.clone();
         let dir = module.path.parent().unwrap_or(Path::new("."));
         for stmt in &module.program.statements {
             match stmt {
-                Statement::Import { specifiers, from, span } => {
+                Statement::Import {
+                    specifiers,
+                    from,
+                    span,
+                } => {
                     if is_native_import(from.as_ref()) {
                         // Normalize fs/http/process -> tish:fs etc. for Node compatibility
-                        let canonical_spec =
-                            normalize_builtin_spec(from.as_ref())
-                                .unwrap_or_else(|| from.to_string());
+                        let canonical_spec = normalize_builtin_spec(from.as_ref())
+                            .unwrap_or_else(|| from.to_string());
                         // Emit VarDecl with NativeModuleLoad for each specifier
                         for spec in specifiers {
                             match spec {
-                                ImportSpecifier::Named { name, alias } => {
+                                ImportSpecifier::Named {
+                                    name,
+                                    name_span,
+                                    alias,
+                                    alias_span,
+                                } => {
                                     let bind = alias.as_deref().unwrap_or(name.as_ref());
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
                                     let init = Expr::NativeModuleLoad {
                                         spec: Arc::from(canonical_spec.clone()),
                                         export_name: name.clone(),
                                         span: *span,
                                     };
-                                    statements.push(Statement::VarDecl {
-                                        name: Arc::from(bind),
-                                        mutable: false,
-                                        type_ann: None,
-                                        init: Some(init),
-                                        span: *span,
-                                    });
+                                    merge_push(
+                                        &mut statements,
+                                        &mut statement_sources,
+                                        Statement::VarDecl {
+                                            name: Arc::from(bind),
+                                            name_span: *decl_name_span,
+                                            mutable: false,
+                                            type_ann: None,
+                                            init: Some(init),
+                                            span: *span,
+                                        },
+                                        src_path.clone(),
+                                    );
                                 }
-                                ImportSpecifier::Namespace(ns) => {
+                                ImportSpecifier::Namespace { name, .. } => {
                                     return Err(format!(
                                         "Namespace import (* as {}) not supported for native module '{}'",
-                                        ns.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref()
                                     ));
                                 }
-                                ImportSpecifier::Default(bind) => {
+                                ImportSpecifier::Default { name, .. } => {
                                     return Err(format!(
                                         "Default import '{}' not supported for native module '{}'. Use named import, e.g. import {{ egui }} from '{}'",
-                                        bind.as_ref(),
+                                        name.as_ref(),
                                         from.as_ref(),
                                         from.as_ref()
                                     ));
@@ -918,35 +1024,45 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                         continue;
                     }
                     let dep_path = resolve_import_path(from.as_ref(), dir, Path::new("."))?;
-                    let dep_path = dep_path
-                        .canonicalize()
-                        .unwrap_or(dep_path);
+                    let dep_path = dep_path.canonicalize().unwrap_or(dep_path);
                     let dep_idx = *path_to_idx
                         .get(&dep_path)
                         .ok_or_else(|| format!("Resolved import '{}' not in module list", from))?;
                     let dep_exports = &module_exports[dep_idx];
                     for spec in specifiers {
                         match spec {
-                            ImportSpecifier::Named { name, alias } => {
+                            ImportSpecifier::Named {
+                                name,
+                                name_span,
+                                alias,
+                                alias_span,
+                            } => {
                                 let source = dep_exports
                                     .get(name.as_ref())
                                     .cloned()
                                     .unwrap_or_else(|| name.to_string());
                                 let bind = alias.as_deref().unwrap_or(name.as_ref());
                                 if bind != source {
-                                    statements.push(Statement::VarDecl {
-                                        name: Arc::from(bind),
-                                        mutable: false,
-                                        type_ann: None,
-                                        init: Some(Expr::Ident {
-                                            name: Arc::from(source),
+                                    let decl_name_span = alias_span.as_ref().unwrap_or(name_span);
+                                    merge_push(
+                                        &mut statements,
+                                        &mut statement_sources,
+                                        Statement::VarDecl {
+                                            name: Arc::from(bind),
+                                            name_span: *decl_name_span,
+                                            mutable: false,
+                                            type_ann: None,
+                                            init: Some(Expr::Ident {
+                                                name: Arc::from(source),
+                                                span: *span,
+                                            }),
                                             span: *span,
-                                        }),
-                                        span: *span,
-                                    });
+                                        },
+                                        src_path.clone(),
+                                    );
                                 }
                             }
-                            ImportSpecifier::Namespace(ns) => {
+                            ImportSpecifier::Namespace { name, name_span } => {
                                 let mut props = Vec::new();
                                 for (k, v) in dep_exports {
                                     props.push(tishlang_ast::ObjectProp::KeyValue(
@@ -957,58 +1073,83 @@ pub fn merge_modules(modules: Vec<ResolvedModule>) -> Result<Program, String> {
                                         },
                                     ));
                                 }
-                                statements.push(Statement::VarDecl {
-                                    name: ns.clone(),
-                                    mutable: false,
-                                    type_ann: None,
-                                    init: Some(Expr::Object {
-                                        props,
+                                merge_push(
+                                    &mut statements,
+                                    &mut statement_sources,
+                                    Statement::VarDecl {
+                                        name: name.clone(),
+                                        name_span: *name_span,
+                                        mutable: false,
+                                        type_ann: None,
+                                        init: Some(Expr::Object { props, span: *span }),
                                         span: *span,
-                                    }),
-                                    span: *span,
-                                });
+                                    },
+                                    src_path.clone(),
+                                );
                             }
-                            ImportSpecifier::Default(bind) => {
-                                let source = dep_exports
-                                    .get("default")
-                                    .cloned()
-                                    .ok_or_else(|| {
+                            ImportSpecifier::Default { name, name_span } => {
+                                let source =
+                                    dep_exports.get("default").cloned().ok_or_else(|| {
                                         format!("Module '{}' has no default export", from)
                                     })?;
-                                statements.push(Statement::VarDecl {
-                                    name: bind.clone(),
-                                    mutable: false,
-                                    type_ann: None,
-                                    init: Some(Expr::Ident {
-                                        name: Arc::from(source),
+                                merge_push(
+                                    &mut statements,
+                                    &mut statement_sources,
+                                    Statement::VarDecl {
+                                        name: name.clone(),
+                                        name_span: *name_span,
+                                        mutable: false,
+                                        type_ann: None,
+                                        init: Some(Expr::Ident {
+                                            name: Arc::from(source),
+                                            span: *span,
+                                        }),
                                         span: *span,
-                                    }),
-                                    span: *span,
-                                });
+                                    },
+                                    src_path.clone(),
+                                );
                             }
                         }
                     }
                 }
-                Statement::Export { declaration, .. } => {
-                    match declaration.as_ref() {
-                        ExportDeclaration::Named(s) => statements.push(*s.clone()),
-                        ExportDeclaration::Default(e) => {
-                            let default_name = format!("__default_{}", idx);
-                            statements.push(Statement::VarDecl {
+                Statement::Export { declaration, .. } => match declaration.as_ref() {
+                    ExportDeclaration::Named(s) => merge_push(
+                        &mut statements,
+                        &mut statement_sources,
+                        *s.clone(),
+                        src_path.clone(),
+                    ),
+                    ExportDeclaration::Default(e) => {
+                        let default_name = format!("__default_{}", idx);
+                        let espan = e.span();
+                        merge_push(
+                            &mut statements,
+                            &mut statement_sources,
+                            Statement::VarDecl {
                                 name: Arc::from(default_name),
+                                name_span: espan,
                                 mutable: false,
                                 type_ann: None,
                                 init: Some((*e).clone()),
-                                span: e.span(),
-                            });
-                        }
+                                span: espan,
+                            },
+                            src_path.clone(),
+                        );
                     }
-                }
-                _ => statements.push(stmt.clone()),
+                },
+                _ => merge_push(
+                    &mut statements,
+                    &mut statement_sources,
+                    stmt.clone(),
+                    src_path.clone(),
+                ),
             }
         }
     }
-    Ok(Program { statements })
+    Ok(MergedProgram {
+        program: Program { statements },
+        statement_sources,
+    })
 }
 
 #[cfg(test)]
@@ -1045,14 +1186,14 @@ mod cargo_spec_tests {
         std::fs::write(&p, src).unwrap();
         let root = dir.path();
         let modules = resolve_project(&p, Some(root)).unwrap();
-        merge_modules(modules).unwrap();
+        let _ = merge_modules(modules).unwrap();
     }
 
     #[test]
     fn cargo_export_fn_name_sanitizes() {
         assert_eq!(
-            cargo_export_fn_name("cargo:serde_json"),
-            "cargo_native_serde_json_object"
+            cargo_export_fn_name("cargo:tish_serde_json"),
+            "cargo_native_tish_serde_json_object"
         );
         assert_eq!(
             cargo_export_fn_name("cargo:my-crate"),