@tishlang/tish 1.13.2 → 2.0.1

package/crates/tish_compile/src/resolve.rs

@@ -4,7 +4,11 @@
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
-use tishlang_ast::{ExportDeclaration, Expr, ImportSpecifier, MemberProp, Program, Statement, CallArg};
+use tishlang_ast::{
+    ArrayElement, ArrowBody, CallArg, DestructElement, DestructPattern, ExportDeclaration, Expr,
+    FunParam, ImportSpecifier, JsxAttrValue, JsxChild, JsxProp, MemberProp, ObjectProp, Program,
+    Statement,
+};
 
 /// Resolved native module: crate path and init expression.
 #[derive(Debug, Clone)]
@@ -69,8 +73,8 @@ pub fn normalize_builtin_spec(spec: &str) -> Option<String> {
 pub fn is_builtin_native_spec(spec: &str) -> bool {
     matches!(
         spec,
-        "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws"
-    ) || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
+        "tish:fs" | "tish:http" | "tish:timers" | "tish:process" | "tish:ws" | "tish:tty"
+    ) || matches!(spec, "fs" | "http" | "timers" | "process" | "ws" | "tty")
 }
 
 /// Resolve all native imports in a merged program via package.json lookup.
@@ -128,6 +132,7 @@ pub fn program_uses_document(program: &Program) -> bool {
             Expr::Unary { operand, .. } | Expr::TypeOf { operand, .. } => {
                 expr_uses_document(operand)
             }
+            Expr::Delete { target, .. } => expr_uses_document(target),
             Expr::Call { callee, args, .. } => {
                 expr_uses_document(callee)
                     || args.iter().any(|a| match a {
@@ -206,10 +211,10 @@ pub fn program_uses_document(program: &Program) -> bool {
 
     fn stmt_uses_document(s: &Statement) -> bool {
         match s {
-            Statement::VarDecl { init, .. } => init.as_ref().is_some_and(|e| expr_uses_document(e)),
+            Statement::VarDecl { init, .. } => init.as_ref().is_some_and(expr_uses_document),
             Statement::VarDeclDestructure { init, .. } => expr_uses_document(init),
             Statement::ExprStmt { expr, .. } => expr_uses_document(expr),
-            Statement::Return { value, .. } => value.as_ref().is_some_and(|e| expr_uses_document(e)),
+            Statement::Return { value, .. } => value.as_ref().is_some_and(expr_uses_document),
             Statement::Throw { value, .. } => expr_uses_document(value),
             Statement::If {
                 cond,
@@ -229,8 +234,8 @@ pub fn program_uses_document(program: &Program) -> bool {
             }
             Statement::For { init, cond, update, body, .. } => {
                 init.as_ref().is_some_and(|s| stmt_uses_document(s.as_ref()))
-                    || cond.as_ref().is_some_and(|e| expr_uses_document(e))
-                    || update.as_ref().is_some_and(|e| expr_uses_document(e))
+                    || cond.as_ref().is_some_and(expr_uses_document)
+                    || update.as_ref().is_some_and(expr_uses_document)
                     || stmt_uses_document(body)
             }
             Statement::ForOf { iterable, body, .. } => {
@@ -244,14 +249,16 @@ pub fn program_uses_document(program: &Program) -> bool {
             } => {
                 expr_uses_document(expr)
                     || cases.iter().any(|(e, stmts)| {
-                        e.as_ref().is_some_and(|e| expr_uses_document(e))
+                        e.as_ref().is_some_and(expr_uses_document)
                             || stmts.iter().any(stmt_uses_document)
                     })
                     || default_body
                         .as_ref()
                         .is_some_and(|stmts| stmts.iter().any(stmt_uses_document))
             }
-            Statement::Block { statements, .. } => statements.iter().any(stmt_uses_document),
+            Statement::Block { statements, .. } | Statement::Multi { statements, .. } => {
+                statements.iter().any(stmt_uses_document)
+            }
             Statement::FunDecl { body, .. } => stmt_uses_document(body),
             Statement::Try {
                 body,
@@ -603,7 +610,10 @@ pub fn generate_native_wrapper_rs(
                 key_lit, shim_crate, rust_fn
             ));
         }
-        file.push_str("    Value::Object(VmRef::new(m))\n}\n\n");
+        // `Value::object(m)` wraps the `ObjectMap` into the `ObjectData` that `Value::Object`
+        // now holds; `Value::Object(VmRef::new(m))` (raw map) stopped type-checking after the
+        // PropMap/ObjectData refactor (#78).
+        file.push_str("    Value::object(m)\n}\n\n");
     }
     if !any {
         return String::new();
@@ -747,7 +757,9 @@ pub fn has_native_imports(program: &Program) -> bool {
 pub fn has_external_native_imports(program: &Program) -> bool {
     for stmt in &program.statements {
         for spec in stmt_native_specs(stmt) {
-            if !is_builtin_native_spec(spec.as_ref()) {
+            // `ffi:` is portable (loadable on every backend via the C ABI), so it is NOT an
+            // "external native import" that non-rust backends must reject — only `cargo:` is.
+            if !is_builtin_native_spec(spec.as_ref()) && !is_ffi_native_spec(&spec) {
                 return true;
             }
         }
@@ -755,6 +767,20 @@ pub fn has_external_native_imports(program: &Program) -> bool {
     false
 }
 
+/// Every `ffi:…` spec imported anywhere in `program` (deduplicated, in first-seen order). The CLI
+/// loads each cdylib with `tish_ffi::load_module` and registers it before running.
+pub fn ffi_native_specs(program: &Program) -> Vec<String> {
+    let mut out: Vec<String> = Vec::new();
+    for stmt in &program.statements {
+        for spec in stmt_native_specs(stmt) {
+            if is_ffi_native_spec(&spec) && !out.contains(&spec) {
+                out.push(spec);
+            }
+        }
+    }
+    out
+}
+
 /// A resolved module: path and its parsed program.
 #[derive(Debug, Clone)]
 pub struct ResolvedModule {
@@ -907,28 +933,47 @@ fn load_module_recursive(
 /// - fs, http, timers, process, ws (Node-compatible aliases for tish:*)
 /// - tish:egui, tish:polars, etc.
 /// - cargo:… (Cargo `rustDependencies` + generated wrapper; Rust native backend)
+/// - ffi:… (a C-ABI cdylib loaded via `tish_ffi::load_module` — portable across backends)
 ///
 /// Scoped npm packages (`@scope/pkg`) are merged as Tish source unless imported via `tish:…`.
 pub fn is_native_import(spec: &str) -> bool {
     spec.starts_with("tish:")
         || spec.starts_with("cargo:")
+        || spec.starts_with("ffi:")
         || matches!(spec, "fs" | "http" | "timers" | "process" | "ws")
 }
 
+/// True for `ffi:…` specs (portable C-ABI cdylib extensions, loadable on every backend). The
+/// path after `ffi:` is resolved relative to the importing program and loaded with
+/// `tish_ffi::load_module`. Unlike `cargo:` (rust-AOT only), `ffi:` is allowed everywhere.
+pub fn is_ffi_native_spec(spec: &str) -> bool {
+    spec.starts_with("ffi:")
+}
+
 /// Map native spec to Cargo feature name for built-in tish:* modules.
 pub fn native_spec_to_feature(spec: &str) -> Option<String> {
     let canonical = normalize_builtin_spec(spec)?;
     canonical.strip_prefix("tish:").map(|s| s.to_string())
 }
 
-/// 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> {
+/// Resolve `package.json` at `pkg_root` to the package's main `.tish` entry.
+///
+/// `require_name`: when `Some(spec)`, the package's `package.json` `name` must equal `spec` (used for
+/// the sibling / walk-up heuristic, where a coincidental directory name would otherwise false-match).
+/// When `None`, the directory is authoritative — used for a `node_modules/<spec>` lookup, because npm
+/// installs a dependency under its *dependency key* (the directory), not the package's internal `name`
+/// (e.g. an aliased / scoped package, or a `file:`/workspace link). This matches Node's resolution and
+/// tish's own path-dep rewriting, so a workspace package linked in as `lattish` resolves even though its
+/// own `name` is `@tishlang/lattish`.
+fn resolve_package_entry(pkg_root: &Path, require_name: Option<&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;
+    if let Some(spec) = require_name {
+        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()?;
@@ -958,15 +1003,18 @@ fn resolve_package_root_to_entry(pkg_root: &Path, spec: &str) -> Option<PathBuf>
 pub fn resolve_bare_spec(spec: &str, from_dir: &Path, _project_root: &Path) -> Option<PathBuf> {
     let mut search = from_dir.to_path_buf();
     loop {
-        if let Some(p) =
-            resolve_package_root_to_entry(&search.join("node_modules").join(spec), spec)
-        {
+        // node_modules/<spec>: the directory is authoritative (npm installs by dependency key, like
+        // Node) — do NOT require the package's internal `name` to match, so aliased/scoped/`file:`
+        // workspace packages linked in under this name resolve.
+        if let Some(p) = resolve_package_entry(&search.join("node_modules").join(spec), None) {
             return Some(p);
         }
-        if let Some(p) = resolve_package_root_to_entry(&search.join(spec), spec) {
+        // sibling <spec>/ and the search dir itself: require name match (a bare directory name is a
+        // weaker signal — guard against a coincidental same-named dir in a monorepo walk).
+        if let Some(p) = resolve_package_entry(&search.join(spec), Some(spec)) {
             return Some(p);
         }
-        if let Some(p) = resolve_package_root_to_entry(&search, spec) {
+        if let Some(p) = resolve_package_entry(&search, Some(spec)) {
             return Some(p);
         }
         if let Some(parent) = search.parent() {
@@ -1110,10 +1158,525 @@ fn merge_push(
     statement_sources.push(source);
 }
 
+// ── #97: module-private top-level binding isolation ─────────────────────────────────────
+//
+// All modules are concatenated into one flat program, so two modules that declare the same
+// *non-exported* top-level name (`let SHARED`, `fn err`, …) collide: a silent wrong value at
+// runtime, and a duplicate `let` (SyntaxError) in the `--target js` bundle. We give each such
+// private binding a module-unique name and rewrite references within that module. Exported
+// and imported names are never touched, so the import/export resolution below is unaffected —
+// and a name that doesn't collide is left exactly as-is (zero blast radius).
+
+/// Names a module contributes to the merged flat namespace at its top level.
+/// `decls` = names declared (`let`/`const`/`fn`/destructure), `exported` = the subset that is
+/// exported, `imports` = local names bound by `import`. Type-only declarations are erased.
+fn collect_module_top_level_names(
+    stmts: &[Statement],
+    decls: &mut HashSet<String>,
+    exported: &mut HashSet<String>,
+    imports: &mut HashSet<String>,
+) {
+    for stmt in stmts {
+        match stmt {
+            Statement::VarDecl { name, .. } | Statement::FunDecl { name, .. } => {
+                decls.insert(name.to_string());
+            }
+            Statement::VarDeclDestructure { pattern, .. } => {
+                collect_destructure_names(pattern, decls);
+            }
+            Statement::Multi { statements, .. } => {
+                collect_module_top_level_names(statements, decls, exported, imports);
+            }
+            Statement::Export { declaration, .. } => {
+                if let ExportDeclaration::Named(inner) = declaration.as_ref() {
+                    match inner.as_ref() {
+                        Statement::VarDecl { name, .. } | Statement::FunDecl { name, .. } => {
+                            decls.insert(name.to_string());
+                            exported.insert(name.to_string());
+                        }
+                        Statement::VarDeclDestructure { pattern, .. } => {
+                            let mut names = HashSet::new();
+                            collect_destructure_names(pattern, &mut names);
+                            for n in names {
+                                decls.insert(n.clone());
+                                exported.insert(n);
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            Statement::Import { specifiers, .. } => {
+                for spec in specifiers {
+                    let n = match spec {
+                        ImportSpecifier::Named { name, alias, .. } => {
+                            alias.as_deref().unwrap_or(name).to_string()
+                        }
+                        ImportSpecifier::Namespace { name, .. }
+                        | ImportSpecifier::Default { name, .. } => name.to_string(),
+                    };
+                    imports.insert(n);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+fn collect_destructure_names(pattern: &DestructPattern, out: &mut HashSet<String>) {
+    let push = |el: &DestructElement, out: &mut HashSet<String>| match el {
+        DestructElement::Ident(n, _) | DestructElement::Rest(n, _) => {
+            out.insert(n.to_string());
+        }
+        DestructElement::Pattern(p) => collect_destructure_names(p, out),
+    };
+    match pattern {
+        DestructPattern::Array(elements) => {
+            for el in elements.iter().flatten() {
+                push(el, out);
+            }
+        }
+        DestructPattern::Object(props) => {
+            for p in props {
+                push(&p.value, out);
+            }
+        }
+    }
+}
+
+/// Rename each module's non-exported top-level bindings whose name also occurs as a top-level
+/// name in another module, isolating module-private declarations (#97).
+fn isolate_private_top_level_bindings(modules: &mut [ResolvedModule]) {
+    let n = modules.len();
+    if n < 2 {
+        return; // a single module cannot collide with another
+    }
+    let mut decls: Vec<HashSet<String>> = vec![HashSet::new(); n];
+    let mut exported: Vec<HashSet<String>> = vec![HashSet::new(); n];
+    // `occupancy[i]` = every top-level name module i contributes (decls ∪ import bindings).
+    let mut occupancy: Vec<HashSet<String>> = vec![HashSet::new(); n];
+    for (i, m) in modules.iter().enumerate() {
+        let mut imports = HashSet::new();
+        collect_module_top_level_names(
+            &m.program.statements,
+            &mut decls[i],
+            &mut exported[i],
+            &mut imports,
+        );
+        occupancy[i] = decls[i].union(&imports).cloned().collect();
+    }
+    // How many modules contribute each top-level name.
+    let mut count: HashMap<&str, usize> = HashMap::new();
+    for occ in &occupancy {
+        for name in occ {
+            *count.entry(name.as_str()).or_insert(0) += 1;
+        }
+    }
+    for (i, m) in modules.iter_mut().enumerate() {
+        let mut renames: HashMap<String, Arc<str>> = HashMap::new();
+        for name in &decls[i] {
+            if exported[i].contains(name) {
+                continue; // exported names stay stable so imports keep resolving
+            }
+            if count.get(name.as_str()).copied().unwrap_or(0) > 1 {
+                renames.insert(name.clone(), Arc::from(format!("{name}__m{i}")));
+            }
+        }
+        if renames.is_empty() {
+            continue;
+        }
+        for stmt in &mut m.program.statements {
+            // Each top-level statement starts from the full rename set (module top level is a
+            // single scope; nested scopes shadow within their own cloned set).
+            let mut active = renames.clone();
+            rewrite_stmt_scope(stmt, &mut active, true);
+        }
+    }
+}
+
+/// Apply the rename for a *declared* name. At module top level the binding is the canonical
+/// private one — rename it. In a nested scope the same name is a shadow — drop it from `active`
+/// so the inner binding and its references keep their own identity.
+fn apply_binding(name: &mut Arc<str>, active: &mut HashMap<String, Arc<str>>, top_level: bool) {
+    if top_level {
+        if let Some(renamed) = active.get(name.as_ref()) {
+            *name = Arc::clone(renamed);
+        }
+    } else {
+        active.remove(name.as_ref());
+    }
+}
+
+/// Rename / shadow the names bound by a destructuring pattern (mirrors [`apply_binding`]).
+fn rewrite_destructure_binding(
+    pattern: &mut DestructPattern,
+    active: &mut HashMap<String, Arc<str>>,
+    top_level: bool,
+) {
+    fn one(el: &mut DestructElement, active: &mut HashMap<String, Arc<str>>, top_level: bool) {
+        match el {
+            DestructElement::Ident(n, _) | DestructElement::Rest(n, _) => {
+                if top_level {
+                    if let Some(renamed) = active.get(n.as_ref()) {
+                        *n = Arc::clone(renamed);
+                    }
+                } else {
+                    active.remove(n.as_ref());
+                }
+            }
+            DestructElement::Pattern(p) => rewrite_destructure_binding(p, active, top_level),
+        }
+    }
+    match pattern {
+        DestructPattern::Array(elements) => {
+            for el in elements.iter_mut().flatten() {
+                one(el, active, top_level);
+            }
+        }
+        DestructPattern::Object(props) => {
+            for p in props.iter_mut() {
+                one(&mut p.value, active, top_level); // p.key is the source property — untouched
+            }
+        }
+    }
+}
+
+/// Remove function/arrow parameter names from a (child-scope) rename set so the body's
+/// references to them are not rewritten, and rewrite any default-value expressions in the
+/// enclosing scope.
+fn shadow_params(
+    params: &mut [FunParam],
+    child: &mut HashMap<String, Arc<str>>,
+    parent: &HashMap<String, Arc<str>>,
+) {
+    for p in params.iter_mut() {
+        match p {
+            FunParam::Simple(tp) => {
+                if let Some(d) = &mut tp.default {
+                    rewrite_expr_scope(d, parent);
+                }
+                child.remove(tp.name.as_ref());
+            }
+            FunParam::Destructure {
+                pattern, default, ..
+            } => {
+                if let Some(d) = default {
+                    rewrite_expr_scope(d, parent);
+                }
+                let mut names = HashSet::new();
+                collect_destructure_names(pattern, &mut names);
+                for n in &names {
+                    child.remove(n);
+                }
+            }
+        }
+    }
+}
+
+/// Scope-aware statement rewriter for [`isolate_private_top_level_bindings`].
+fn rewrite_stmt_scope(
+    stmt: &mut Statement,
+    active: &mut HashMap<String, Arc<str>>,
+    top_level: bool,
+) {
+    match stmt {
+        Statement::VarDecl { name, init, .. } => {
+            if let Some(e) = init {
+                rewrite_expr_scope(e, active);
+            }
+            apply_binding(name, active, top_level);
+        }
+        Statement::VarDeclDestructure { pattern, init, .. } => {
+            rewrite_expr_scope(init, active);
+            rewrite_destructure_binding(pattern, active, top_level);
+        }
+        Statement::Multi { statements, .. } => {
+            // Same-scope group (`let a = 1, b = 2`): thread `active`, keep `top_level`.
+            for s in statements {
+                rewrite_stmt_scope(s, active, top_level);
+            }
+        }
+        Statement::ExprStmt { expr, .. } => rewrite_expr_scope(expr, active),
+        Statement::Block { statements, .. } => {
+            let mut child = active.clone();
+            for s in statements {
+                rewrite_stmt_scope(s, &mut child, false);
+            }
+        }
+        Statement::If {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            rewrite_expr_scope(cond, active);
+            rewrite_stmt_scope(then_branch, &mut active.clone(), false);
+            if let Some(e) = else_branch {
+                rewrite_stmt_scope(e, &mut active.clone(), false);
+            }
+        }
+        Statement::While { cond, body, .. } => {
+            rewrite_expr_scope(cond, active);
+            rewrite_stmt_scope(body, &mut active.clone(), false);
+        }
+        Statement::DoWhile { body, cond, .. } => {
+            rewrite_stmt_scope(body, &mut active.clone(), false);
+            rewrite_expr_scope(cond, active);
+        }
+        Statement::For {
+            init,
+            cond,
+            update,
+            body,
+            ..
+        } => {
+            let mut child = active.clone();
+            if let Some(i) = init {
+                rewrite_stmt_scope(i, &mut child, false);
+            }
+            if let Some(e) = cond {
+                rewrite_expr_scope(e, &child);
+            }
+            if let Some(e) = update {
+                rewrite_expr_scope(e, &child);
+            }
+            rewrite_stmt_scope(body, &mut child, false);
+        }
+        Statement::ForOf {
+            name,
+            iterable,
+            body,
+            ..
+        } => {
+            rewrite_expr_scope(iterable, active);
+            let mut child = active.clone();
+            child.remove(name.as_ref()); // loop variable shadows
+            rewrite_stmt_scope(body, &mut child, false);
+        }
+        Statement::Return { value, .. } => {
+            if let Some(e) = value {
+                rewrite_expr_scope(e, active);
+            }
+        }
+        Statement::Throw { value, .. } => rewrite_expr_scope(value, active),
+        Statement::Break { .. } | Statement::Continue { .. } => {}
+        Statement::FunDecl {
+            name,
+            params,
+            rest_param,
+            body,
+            ..
+        } => {
+            apply_binding(name, active, top_level);
+            let mut child = active.clone();
+            shadow_params(params, &mut child, active);
+            if let Some(rp) = rest_param {
+                child.remove(rp.name.as_ref());
+            }
+            rewrite_stmt_scope(body, &mut child, false);
+        }
+        Statement::Switch {
+            expr,
+            cases,
+            default_body,
+            ..
+        } => {
+            rewrite_expr_scope(expr, active);
+            // A switch body shares one block scope across all cases.
+            let mut child = active.clone();
+            for (test, body) in cases.iter_mut() {
+                if let Some(t) = test {
+                    rewrite_expr_scope(t, &child);
+                }
+                for s in body {
+                    rewrite_stmt_scope(s, &mut child, false);
+                }
+            }
+            if let Some(body) = default_body {
+                for s in body {
+                    rewrite_stmt_scope(s, &mut child, false);
+                }
+            }
+        }
+        Statement::Try {
+            body,
+            catch_param,
+            catch_body,
+            finally_body,
+            ..
+        } => {
+            rewrite_stmt_scope(body, &mut active.clone(), false);
+            if let Some(cb) = catch_body {
+                let mut child = active.clone();
+                if let Some(p) = catch_param {
+                    child.remove(p.as_ref()); // catch binding shadows
+                }
+                rewrite_stmt_scope(cb, &mut child, false);
+            }
+            if let Some(fb) = finally_body {
+                rewrite_stmt_scope(fb, &mut active.clone(), false);
+            }
+        }
+        Statement::Export { declaration, .. } => match declaration.as_mut() {
+            // Exported declarations keep their name (not in `active`), but their initializer /
+            // body can still reference module-private names that were renamed.
+            ExportDeclaration::Named(inner) => rewrite_stmt_scope(inner, active, top_level),
+            ExportDeclaration::Default(e) => rewrite_expr_scope(e, active),
+        },
+        Statement::Import { .. }
+        | Statement::TypeAlias { .. }
+        | Statement::DeclareVar { .. }
+        | Statement::DeclareFun { .. } => {}
+    }
+}
+
+/// Scope-aware expression rewriter: rename every free reference to a name in `active`.
+/// Expressions never declare module-level bindings, so `active` is read-only here; arrow
+/// functions clone it for their own (shadowed) parameter scope.
+fn rewrite_expr_scope(expr: &mut Expr, active: &HashMap<String, Arc<str>>) {
+    let rename = |name: &mut Arc<str>| {
+        if let Some(renamed) = active.get(name.as_ref()) {
+            *name = Arc::clone(renamed);
+        }
+    };
+    match expr {
+        Expr::Ident { name, .. } => rename(name),
+        Expr::Assign { name, value, .. }
+        | Expr::CompoundAssign { name, value, .. }
+        | Expr::LogicalAssign { name, value, .. } => {
+            rename(name);
+            rewrite_expr_scope(value, active);
+        }
+        Expr::PostfixInc { name, .. }
+        | Expr::PostfixDec { name, .. }
+        | Expr::PrefixInc { name, .. }
+        | Expr::PrefixDec { name, .. } => rename(name),
+        Expr::Binary { left, right, .. } => {
+            rewrite_expr_scope(left, active);
+            rewrite_expr_scope(right, active);
+        }
+        Expr::Unary { operand, .. } | Expr::TypeOf { operand, .. } | Expr::Await { operand, .. } => {
+            rewrite_expr_scope(operand, active)
+        }
+        Expr::Delete { target, .. } => rewrite_expr_scope(target, active),
+        Expr::Call { callee, args, .. } | Expr::New { callee, args, .. } => {
+            rewrite_expr_scope(callee, active);
+            for a in args {
+                match a {
+                    CallArg::Expr(e) | CallArg::Spread(e) => rewrite_expr_scope(e, active),
+                }
+            }
+        }
+        Expr::Member { object, prop, .. } => {
+            rewrite_expr_scope(object, active);
+            if let MemberProp::Expr(e) = prop {
+                rewrite_expr_scope(e, active); // computed key; `obj.name` is untouched
+            }
+        }
+        Expr::Index { object, index, .. } => {
+            rewrite_expr_scope(object, active);
+            rewrite_expr_scope(index, active);
+        }
+        Expr::Conditional {
+            cond,
+            then_branch,
+            else_branch,
+            ..
+        } => {
+            rewrite_expr_scope(cond, active);
+            rewrite_expr_scope(then_branch, active);
+            rewrite_expr_scope(else_branch, active);
+        }
+        Expr::NullishCoalesce { left, right, .. } => {
+            rewrite_expr_scope(left, active);
+            rewrite_expr_scope(right, active);
+        }
+        Expr::Array { elements, .. } => {
+            for el in elements {
+                match el {
+                    ArrayElement::Expr(e) | ArrayElement::Spread(e) => rewrite_expr_scope(e, active),
+                }
+            }
+        }
+        Expr::Object { props, .. } => {
+            for p in props {
+                match p {
+                    ObjectProp::KeyValue(_, e) | ObjectProp::Spread(e) => {
+                        rewrite_expr_scope(e, active) // key is a property name; value recurses
+                    }
+                }
+            }
+        }
+        Expr::MemberAssign { object, value, .. } => {
+            rewrite_expr_scope(object, active);
+            rewrite_expr_scope(value, active);
+        }
+        Expr::IndexAssign {
+            object,
+            index,
+            value,
+            ..
+        } => {
+            rewrite_expr_scope(object, active);
+            rewrite_expr_scope(index, active);
+            rewrite_expr_scope(value, active);
+        }
+        Expr::ArrowFunction { params, body, .. } => {
+            let mut child = active.clone();
+            shadow_params(params, &mut child, active);
+            match body {
+                ArrowBody::Expr(e) => rewrite_expr_scope(e, &child),
+                ArrowBody::Block(s) => rewrite_stmt_scope(s, &mut child, false),
+            }
+        }
+        Expr::TemplateLiteral { exprs, .. } => {
+            for e in exprs {
+                rewrite_expr_scope(e, active);
+            }
+        }
+        Expr::JsxElement {
+            tag,
+            props,
+            children,
+            ..
+        } => {
+            // `<Component …>` references a binding; lowercase HTML tags aren't in `active`.
+            if let Some(renamed) = active.get(tag.as_ref()) {
+                *tag = Arc::clone(renamed);
+            }
+            for prop in props {
+                match prop {
+                    JsxProp::Attr { value, .. } => match value {
+                        JsxAttrValue::Expr(e) => rewrite_expr_scope(e, active),
+                        JsxAttrValue::String(_) | JsxAttrValue::ImplicitTrue => {}
+                    },
+                    JsxProp::Spread(e) => rewrite_expr_scope(e, active),
+                }
+            }
+            for child in children {
+                if let JsxChild::Expr(e) = child {
+                    rewrite_expr_scope(e, active);
+                }
+            }
+        }
+        Expr::JsxFragment { children, .. } => {
+            for child in children {
+                if let JsxChild::Expr(e) = child {
+                    rewrite_expr_scope(e, active);
+                }
+            }
+        }
+        Expr::Literal { .. } | Expr::NativeModuleLoad { .. } => {}
+    }
+}
+
 /// 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<MergedProgram, String> {
+pub fn merge_modules(mut modules: Vec<ResolvedModule>) -> Result<MergedProgram, String> {
+    // #97: isolate module-private top-level bindings before they are flattened together.
+    isolate_private_top_level_bindings(&mut modules);
+
     let path_to_idx: HashMap<PathBuf, usize> = modules
         .iter()
         .enumerate()