crates/core/src/unpacker/esbuild.rs

GitHub
use std::collections::{HashMap, HashSet};

use swc_core::atoms::Atom;
use swc_core::common::{
    sync::Lrc, FileName, Mark, SourceMap, Span, Spanned, SyntaxContext, DUMMY_SP, GLOBALS,
};
use swc_core::ecma::ast::{
    ArrowExpr, AssignTarget, AssignTargetPat, BindingIdent, BlockStmt, BlockStmtOrExpr, Bool,
    CallExpr, Callee, ClassDecl, Decl, ExportDecl, ExportNamedSpecifier, ExportSpecifier, Expr,
    ExprOrSpread, ExprStmt, FnDecl, ForInStmt, Function, Ident, IdentName, ImportDecl,
    ImportNamedSpecifier, ImportSpecifier, KeyValueProp, Lit, MemberExpr, MemberProp, Module,
    ModuleDecl, ModuleExportName, ModuleItem, NamedExport, ObjectLit, ObjectPatProp, Pat, Prop,
    PropName, PropOrSpread, SimpleAssignTarget, Stmt, Str, VarDeclarator,
};
use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::utils::find_pat_ids;
use swc_core::ecma::visit::{Visit, VisitMutWith, VisitWith};

use crate::module_path::relative_import_specifier;
use crate::rules::rename_utils::{rename_bindings, BindingRename};
use crate::unpacker::{
    module_item_declared_binding_ids, span_byte_range, spans_byte_ranges, BindingId, BundleFormat,
    UnpackResult, UnpackedModule,
};

pub fn detect_and_extract(source: &str) -> Option<UnpackResult> {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let module = super::parse_es_module(source, "esbuild.js", cm.clone()).ok()?;
        detect_from_module_with_source(&module, Some(source), cm)
    })
}

pub(super) fn detect_from_module_with_source(
    module: &Module,
    source: Option<&str>,
    cm: Lrc<SourceMap>,
) -> Option<UnpackResult> {
    // Phase 1: cheap structural pre-checks on the unresolved module.
    // Both scans are O(top-level items) with no cloning or resolution.
    let helper_syms = {
        let span = tracing::info_span!("esbuild: collect helper syms");
        let _enter = span.enter();
        collect_helper_syms(module)
    };

    let has_export_helper_shape = detect_export_helper(&module.body).is_some();

    if helper_syms.is_empty() && !has_export_helper_shape {
        return None;
    }

    // Evidence of esbuild structure found — clone + resolve for binding analysis.
    let analysis_module = {
        let span = tracing::info_span!("esbuild: clone and resolve for analysis");
        let _enter = span.enter();
        let mut am = module.clone();
        am.visit_mut_with(&mut resolver(Mark::new(), Mark::new(), false));
        am
    };

    let commonjs_helper_syms = collect_commonjs_helper_syms(module);
    let filename_hints = source.map(|source| {
        let source_file = cm.lookup_source_file(module.span.lo);
        PathCommentHints::new(source, source_file.start_pos.0)
    });

    // Phase 2: collect factory declarations — `var X = helper(factory_fn)`.
    let factories = if helper_syms.is_empty() {
        vec![]
    } else {
        let span = tracing::info_span!("esbuild: collect factories");
        let _enter = span.enter();
        collect_factories(
            module,
            &analysis_module,
            &helper_syms,
            &commonjs_helper_syms,
            filename_hints.as_ref(),
        )
    };
    let helper_syms: HashSet<Atom> = factories
        .iter()
        .map(|factory| factory.helper_sym.clone())
        .collect();

    let has_cjs_factories = !commonjs_helper_syms.is_empty()
        && factories
            .iter()
            .any(|f| commonjs_helper_syms.contains(&f.helper_sym));
    let has_factories = has_cjs_factories || factories.len() >= 5;

    // Try scope-hoisted detection on the full module body (needed for
    // scope-only bundles that have no factories at all).
    let has_scope_hoisted = {
        let span = tracing::info_span!("esbuild: detect scope-hoisted");
        let _enter = span.enter();
        detect_export_helper(&analysis_module.body)
            .map(|(_, helper)| {
                let boundaries = collect_scope_hoisted_boundaries(&analysis_module.body, &helper);
                match boundaries.len() {
                    0 => false,
                    1 => {
                        let refs = build_item_binding_infos(&analysis_module.body);
                        namespace_is_module_exported(
                            &analysis_module.body,
                            &refs,
                            &boundaries[0].ns_binding,
                        )
                    }
                    _ => true,
                }
            })
            .unwrap_or(false)
    };

    if !has_factories && !has_scope_hoisted {
        return None;
    }

    let factory_syms: HashSet<Atom> = factories.iter().map(|f| f.var_name.clone()).collect();

    // Phase 3: assign filenames to factories (dedup), collect their referenced
    // bindings from the resolved AST.  Emission is deferred to Phase 6 so that
    // scope-hoisted extraction can inform import/export synthesis.
    let mut modules: Vec<UnpackedModule> = Vec::new();
    let mut global_seen: HashSet<String> = HashSet::new();
    global_seen.insert("entry.js".to_string());

    // Build top_level_bindings from the FULL analysis module so we can track
    // which identifiers referenced by factory bodies are top-level declarations
    // (potentially belonging to scope-hoisted modules).
    let all_top_level_bindings: HashSet<BindingId> = analysis_module
        .body
        .iter()
        .flat_map(|item| {
            module_item_declared_binding_ids(item)
                .into_iter()
                .chain(module_item_import_binding_ids(item))
        })
        .collect();
    let external_imports = collect_external_imports(&analysis_module.body, &module.body);
    let mut top_level_decl_items: HashMap<BindingId, (usize, ModuleItem, ModuleItem)> =
        HashMap::new();
    for (index, (analysis_item, source_item)) in analysis_module
        .body
        .iter()
        .zip(module.body.iter())
        .enumerate()
    {
        for binding in module_item_declared_binding_ids(analysis_item) {
            top_level_decl_items
                .entry(binding)
                .or_insert_with(|| (index, source_item.clone(), analysis_item.clone()));
        }
    }
    let top_level_decl_binding_by_atom = atom_binding_map_from_keys(&top_level_decl_items);

    struct PendingFactory {
        binding: BindingId,
        var_name: Atom,
        filename: String,
        cjs_params: Option<CjsFactoryParams>,
        body_stmts: Vec<Stmt>,
        referenced_bindings: HashSet<BindingId>,
        write_bindings: HashSet<BindingId>,
        span: Span,
    }

    let mut pending_factories: Vec<PendingFactory> = Vec::new();
    for factory in factories {
        let filename = dedup_filename(&factory.filename, &mut global_seen);

        // Collect which top-level bindings this factory's body references
        // by visiting the resolved (analysis) body stmts.
        let mut referenced_bindings = HashSet::new();
        let mut write_bindings = HashSet::new();
        for stmt in &factory.analysis_body_stmts {
            let mut collector = TopLevelRefCollector {
                top_level_bindings: &all_top_level_bindings,
                references: HashSet::new(),
            };
            stmt.visit_with(&mut collector);
            referenced_bindings.extend(collector.references.clone());
            collect_write_bindings(stmt, &all_top_level_bindings, &mut write_bindings);
        }

        pending_factories.push(PendingFactory {
            binding: factory.binding,
            var_name: factory.var_name,
            filename,
            cjs_params: factory.cjs_params,
            body_stmts: factory.body_stmts,
            referenced_bindings,
            write_bindings,
            span: factory.span,
        });
    }

    // Aggregate all factory-referenced bindings for scope-hoisted export expansion.
    let all_factory_referenced: HashSet<BindingId> = pending_factories
        .iter()
        .flat_map(|f| f.referenced_bindings.iter().cloned())
        .collect();
    let mut factory_preassigned_bindings: HashMap<BindingId, String> = HashMap::new();
    for factory in &pending_factories {
        if factory.cjs_params.is_some() {
            continue;
        }
        factory_preassigned_bindings.insert(factory.binding.clone(), factory.filename.clone());
        for write_binding in &factory.write_bindings {
            factory_preassigned_bindings.insert(write_binding.clone(), factory.filename.clone());
        }
    }
    let mut factory_importable_bindings = factory_preassigned_bindings.clone();
    factory_importable_bindings.extend(
        pending_factories
            .iter()
            .filter(|factory| factory.cjs_params.is_none() || factory.write_bindings.is_empty())
            .map(|factory| (factory.binding.clone(), factory.filename.clone())),
    );
    for factory in &pending_factories {
        for ref_binding in &factory.referenced_bindings {
            if factory.write_bindings.contains(ref_binding)
                || factory_importable_bindings.contains_key(ref_binding)
                || helper_syms.contains(&ref_binding.0)
                || factory_syms.contains(&ref_binding.0)
                || !top_level_decl_items.contains_key(ref_binding)
            {
                continue;
            }
            factory_importable_bindings.insert(ref_binding.clone(), factory.filename.clone());
        }
    }

    // Phase 4: everything that is not a helper decl or factory decl becomes the entry.
    // Mixed declarations can contain useful sibling helpers, for example
    // `var wrap = ..., __esm = ...`; filter at declarator granularity.
    let helper_factory_syms: HashSet<Atom> = helper_syms
        .iter()
        .chain(factory_syms.iter())
        .cloned()
        .collect();
    let mut drop_unowned_helper_sibling_indices = HashSet::new();
    let mut entry_items = Vec::new();
    let mut analysis_entry_items = Vec::new();
    for (source_item, analysis_item) in module.body.iter().zip(&analysis_module.body) {
        let source_filtered = filter_helper_factory_declarators(source_item, &helper_factory_syms);
        let analysis_filtered =
            filter_helper_factory_declarators(analysis_item, &helper_factory_syms);
        if source_filtered.is_some() != analysis_filtered.is_some() {
            continue;
        }
        let Some(source_filtered) = source_filtered else {
            continue;
        };
        let Some(analysis_filtered) = analysis_filtered else {
            continue;
        };
        if item_has_helper_factory_declarator(analysis_item, &helper_factory_syms) {
            drop_unowned_helper_sibling_indices.insert(entry_items.len());
        }
        entry_items.push(source_filtered);
        analysis_entry_items.push(analysis_filtered);
    }

    // Phase 5: split scope-hoisted modules out of the entry items.
    // Pass factory-referenced bindings so the extraction can expand exports
    // and return binding→module mapping for factory import synthesis.
    let (
        scope_hoisted_modules,
        remaining_entry,
        mut binding_to_filename,
        module_already_imports,
        module_local_atoms,
        module_referenced_atoms,
        scope_claimed_factory_bindings,
    ) = {
        let span = tracing::info_span!("esbuild: extract scope-hoisted modules");
        let _enter = span.enter();
        extract_scope_hoisted_modules(
            &analysis_entry_items,
            entry_items,
            &mut global_seen,
            cm.clone(),
            ScopeExtractionRefs {
                factory_referenced: &all_factory_referenced,
                factory_preassigned_bindings: &factory_preassigned_bindings,
                factory_importable_bindings: &factory_importable_bindings,
                drop_unowned_helper_sibling_indices: &drop_unowned_helper_sibling_indices,
            },
        )
    };
    modules.extend(scope_hoisted_modules);

    // Phase 6: emit each factory module, now with synthesized imports for any
    // references to scope-hoisted module bindings.
    //
    // Init-factory merging: if a factory writes to bindings that ALL belong to
    // a single scope-hoisted module, it's an init function for that module.
    // Merge its body into the target module rather than emitting a separate file
    // with invalid ESM (imports are read-only, so `import {x} ...; x = ...`
    // would be a runtime error).
    struct MergedFactory {
        var_name: Atom,
        cjs_params: Option<CjsFactoryParams>,
        stmts: Vec<Stmt>,
        referenced_bindings: HashSet<BindingId>,
        write_bindings: HashSet<BindingId>,
    }

    let mut merged_factories: HashMap<String, Vec<MergedFactory>> = HashMap::new();
    let mut standalone_factories: Vec<PendingFactory> = Vec::new();
    let mut factory_owned_bindings: HashMap<String, HashSet<BindingId>> = HashMap::new();

    for factory in pending_factories {
        if factory.write_bindings.is_empty() {
            standalone_factories.push(factory);
            continue;
        }

        // Check if all write targets belong to the same scope-hoisted module.
        let mut target_filename: Option<String> = None;
        let mut is_single_target = true;
        for wb in &factory.write_bindings {
            if let Some(fname) = binding_to_filename.get(wb) {
                match &target_filename {
                    None => target_filename = Some(fname.clone()),
                    Some(existing) if existing == fname => {}
                    Some(_) => {
                        is_single_target = false;
                        break;
                    }
                }
            } else {
                is_single_target = false;
                break;
            }
        }

        let is_scope_claimed_init = factory
            .write_bindings
            .iter()
            .any(|binding| scope_claimed_factory_bindings.contains_key(binding));
        let can_merge = factory.cjs_params.is_some() || is_scope_claimed_init;

        if let (true, Some(fname), true) = (is_single_target, target_filename, can_merge) {
            binding_to_filename.insert(factory.binding.clone(), fname.clone());
            for write_binding in &factory.write_bindings {
                let owned_binding = top_level_decl_binding_by_atom
                    .get(&write_binding.0)
                    .unwrap_or(write_binding);
                if scope_claimed_factory_bindings.contains_key(write_binding)
                    || scope_claimed_factory_bindings.contains_key(owned_binding)
                {
                    binding_to_filename.insert(owned_binding.clone(), fname.clone());
                    factory_owned_bindings
                        .entry(fname.clone())
                        .or_default()
                        .insert(owned_binding.clone());
                }
            }
            merged_factories
                .entry(fname)
                .or_default()
                .push(MergedFactory {
                    var_name: factory.var_name,
                    cjs_params: factory.cjs_params,
                    stmts: factory.body_stmts,
                    referenced_bindings: factory.referenced_bindings,
                    write_bindings: factory.write_bindings,
                });
        } else {
            standalone_factories.push(factory);
        }
    }

    for factory in &standalone_factories {
        binding_to_filename
            .entry(factory.binding.clone())
            .or_insert_with(|| factory.filename.clone());
        for write_binding in &factory.write_bindings {
            binding_to_filename
                .entry(write_binding.clone())
                .or_insert_with(|| factory.filename.clone());
            factory_owned_bindings
                .entry(factory.filename.clone())
                .or_default()
                .insert(write_binding.clone());
        }
    }
    for factory in &standalone_factories {
        for ref_binding in &factory.referenced_bindings {
            if factory.write_bindings.contains(ref_binding)
                || binding_to_filename.contains_key(ref_binding)
                || helper_syms.contains(&ref_binding.0)
                || factory_syms.contains(&ref_binding.0)
                || !top_level_decl_items.contains_key(ref_binding)
            {
                continue;
            }
            binding_to_filename.insert(ref_binding.clone(), factory.filename.clone());
            factory_owned_bindings
                .entry(factory.filename.clone())
                .or_default()
                .insert(ref_binding.clone());
        }
    }
    let mut changed = true;
    while changed {
        changed = false;
        for factory in &standalone_factories {
            let owned_analysis_decl_items = factory_owned_analysis_decl_items(
                &factory.filename,
                &factory_owned_bindings,
                &top_level_decl_items,
            );
            for item in &owned_analysis_decl_items {
                let mut collector = TopLevelRefCollector {
                    top_level_bindings: &all_top_level_bindings,
                    references: HashSet::new(),
                };
                item.visit_with(&mut collector);
                for ref_binding in collector.references {
                    if binding_to_filename.contains_key(&ref_binding)
                        || helper_syms.contains(&ref_binding.0)
                        || factory_syms.contains(&ref_binding.0)
                        || !top_level_decl_items.contains_key(&ref_binding)
                    {
                        continue;
                    }
                    binding_to_filename.insert(ref_binding.clone(), factory.filename.clone());
                    factory_owned_bindings
                        .entry(factory.filename.clone())
                        .or_default()
                        .insert(ref_binding);
                    changed = true;
                }
            }
        }
    }

    let binding_filename_by_atom = atom_to_filename_binding_map(&binding_to_filename);
    let external_import_by_atom = atom_binding_map_from_keys(&external_imports);

    // Append merged factory bodies to their target modules, synthesizing
    // imports for any cross-module reads the factory body needs.
    if !merged_factories.is_empty() {
        for module in &mut modules {
            let Some(factories) = merged_factories.remove(&module.filename) else {
                continue;
            };
            let mut extra_imports: HashMap<String, Vec<Atom>> = HashMap::new();
            let mut extra_external_imports: HashSet<BindingId> = HashSet::new();
            let mut extra_owned_bindings: HashSet<BindingId> = HashSet::new();
            let mut merged_init_bodies: Vec<(Atom, Vec<Stmt>)> = Vec::new();

            let already_imported = module_already_imports
                .get(&module.filename)
                .cloned()
                .unwrap_or_default();

            for mf in factories {
                if mf.cjs_params.is_some() {
                    continue;
                }
                for write_binding in &mf.write_bindings {
                    let owned_binding = top_level_decl_binding_by_atom
                        .get(&write_binding.0)
                        .unwrap_or(write_binding);
                    if binding_to_filename
                        .get(owned_binding)
                        .is_some_and(|filename| filename == &module.filename)
                        && top_level_decl_items.contains_key(owned_binding)
                    {
                        extra_owned_bindings.insert(owned_binding.clone());
                    }
                }
                for ref_binding in &mf.referenced_bindings {
                    if mf.write_bindings.contains(ref_binding) {
                        continue;
                    }
                    if already_imported.contains(ref_binding) {
                        continue;
                    }
                    if let Some(source_filename) = binding_to_filename.get(ref_binding) {
                        if *source_filename != module.filename {
                            extra_imports
                                .entry(source_filename.clone())
                                .or_default()
                                .push(ref_binding.0.clone());
                        }
                    } else if let Some((source_binding, source_filename)) =
                        binding_filename_by_atom.get(&ref_binding.0)
                    {
                        if *source_filename != module.filename {
                            extra_imports
                                .entry(source_filename.clone())
                                .or_default()
                                .push(source_binding.0.clone());
                        }
                    } else if external_imports.contains_key(ref_binding) {
                        extra_external_imports.insert(ref_binding.clone());
                    } else if let Some(import_binding) = external_import_by_atom.get(&ref_binding.0)
                    {
                        extra_external_imports.insert(import_binding.clone());
                    } else if top_level_decl_items.contains_key(ref_binding) {
                        extra_owned_bindings.insert(ref_binding.clone());
                    }
                }
                merged_init_bodies.push((mf.var_name, mf.stmts));
            }

            let mut changed = true;
            while changed {
                changed = false;
                let owned_bindings: Vec<BindingId> = extra_owned_bindings.iter().cloned().collect();
                for owned_binding in owned_bindings {
                    let Some((_, _, analysis_item)) = top_level_decl_items.get(&owned_binding)
                    else {
                        continue;
                    };
                    let mut collector = TopLevelRefCollector {
                        top_level_bindings: &all_top_level_bindings,
                        references: HashSet::new(),
                    };
                    analysis_item.visit_with(&mut collector);
                    for ref_binding in collector.references {
                        if extra_owned_bindings.contains(&ref_binding)
                            || already_imported.contains(&ref_binding)
                        {
                            continue;
                        }
                        if let Some(source_filename) = binding_to_filename.get(&ref_binding) {
                            if *source_filename != module.filename {
                                extra_imports
                                    .entry(source_filename.clone())
                                    .or_default()
                                    .push(ref_binding.0.clone());
                            }
                        } else if let Some((source_binding, source_filename)) =
                            binding_filename_by_atom.get(&ref_binding.0)
                        {
                            if *source_filename != module.filename {
                                extra_imports
                                    .entry(source_filename.clone())
                                    .or_default()
                                    .push(source_binding.0.clone());
                            }
                        } else if external_imports.contains_key(&ref_binding) {
                            extra_external_imports.insert(ref_binding);
                        } else if let Some(import_binding) =
                            external_import_by_atom.get(&ref_binding.0)
                        {
                            extra_external_imports.insert(import_binding.clone());
                        } else if top_level_decl_items.contains_key(&ref_binding) {
                            extra_owned_bindings.insert(ref_binding);
                            changed = true;
                        }
                    }
                }
            }

            let mut import_items: Vec<ModuleItem> = Vec::new();
            let mut merged_local_atoms = module_local_atoms
                .get(&module.filename)
                .cloned()
                .unwrap_or_default();
            merged_local_atoms.extend(
                binding_to_filename
                    .iter()
                    .filter(|(_, filename)| *filename == &module.filename)
                    .map(|((atom, _), _)| atom.clone()),
            );
            merged_local_atoms.extend(extra_owned_bindings.iter().map(|(atom, _)| atom.clone()));
            let mut external_imports_sorted: Vec<BindingId> =
                extra_external_imports.into_iter().collect();
            external_imports_sorted.sort_by(|a, b| a.0.cmp(&b.0));
            for binding in external_imports_sorted {
                if merged_local_atoms.contains(&binding.0) {
                    continue;
                }
                if let Some(import) = external_imports.get(&binding) {
                    import_items.push(make_external_import_stmt(import));
                }
            }
            let mut source_filenames: Vec<String> = extra_imports.keys().cloned().collect();
            source_filenames.sort();
            if let Some(referenced_atoms) = module_referenced_atoms.get(&module.filename) {
                augment_imports_with_referenced_atoms_for_existing_sources(
                    &mut extra_imports,
                    &module.filename,
                    referenced_atoms,
                    &binding_filename_by_atom,
                    Some(&merged_local_atoms),
                );
                source_filenames = extra_imports.keys().cloned().collect();
                source_filenames.sort();
            }
            for source_filename in source_filenames {
                let names = extra_imports.get_mut(&source_filename).unwrap();
                names.retain(|name| !merged_local_atoms.contains(name));
                names.sort();
                names.dedup();
                if names.is_empty() {
                    continue;
                }
                let rel_path = relative_import_path(&module.filename, &source_filename);
                import_items.push(make_scope_import_stmt(names, &rel_path));
            }

            let module_factory_owned = factory_owned_bindings
                .get(&module.filename)
                .cloned()
                .unwrap_or_default();
            let mut extra_owned_items: Vec<(usize, ModuleItem)> = extra_owned_bindings
                .into_iter()
                .filter(|binding| {
                    module_factory_owned.contains(binding)
                        || module_local_atoms
                            .get(&module.filename)
                            .is_none_or(|local_atoms| !local_atoms.contains(&binding.0))
                })
                .filter_map(|binding| {
                    top_level_decl_items
                        .get(&binding)
                        .map(|(index, source_item, _)| (*index, source_item.clone()))
                })
                .collect();
            extra_owned_items.sort_by_key(|(index, _)| *index);
            extra_owned_items.dedup_by_key(|(index, _)| *index);
            let body_items: Vec<ModuleItem> = import_items
                .into_iter()
                .chain(extra_owned_items.into_iter().map(|(_, item)| item))
                .chain(factory_owned_export_items(
                    &module.filename,
                    &factory_owned_bindings,
                ))
                .collect();
            let extra_code = emit_items(body_items, module.filename.clone(), cm.clone());
            module.code.push('\n');
            module.code.push_str(&extra_code);
            for (name, stmts) in merged_init_bodies {
                module.code.push_str(&emit_esm_init_function_code(
                    &name,
                    stmts,
                    module.filename.clone(),
                    cm.clone(),
                ));
            }
        }
    }

    for factory in standalone_factories {
        let owned_decl_items = factory_owned_decl_items(
            &factory.filename,
            &factory_owned_bindings,
            &top_level_decl_items,
        );
        let owned_analysis_decl_items = factory_owned_analysis_decl_items(
            &factory.filename,
            &factory_owned_bindings,
            &top_level_decl_items,
        );
        let declared_owned_atoms: HashSet<Atom> = owned_decl_items
            .iter()
            .flat_map(module_item_declared_binding_ids)
            .map(|(atom, _)| atom)
            .collect();
        let owned_export_atoms: HashSet<Atom> = factory_owned_bindings
            .get(&factory.filename)
            .into_iter()
            .flat_map(|bindings| bindings.iter())
            .map(|(atom, _)| atom.clone())
            .collect();
        let mut extended_referenced_bindings = factory.referenced_bindings.clone();
        for item in &owned_analysis_decl_items {
            let mut collector = TopLevelRefCollector {
                top_level_bindings: &all_top_level_bindings,
                references: HashSet::new(),
            };
            item.visit_with(&mut collector);
            extended_referenced_bindings.extend(collector.references);
        }

        let mut import_items: Vec<ModuleItem> = Vec::new();
        let mut external_import_bindings: HashSet<BindingId> = HashSet::new();
        let mut import_renames: Vec<BindingRename> = Vec::new();

        if !binding_to_filename.is_empty() {
            // Group factory's referenced bindings by source module filename.
            let mut imports_by_source: HashMap<String, Vec<BindingId>> = HashMap::new();
            let owned = factory_owned_bindings
                .get(&factory.filename)
                .cloned()
                .unwrap_or_default();
            for ref_binding in &extended_referenced_bindings {
                // Don't import bindings that this factory writes to.
                if factory.write_bindings.contains(ref_binding)
                    || owned.contains(ref_binding)
                    || declared_owned_atoms.contains(&ref_binding.0)
                {
                    continue;
                }
                if let Some(source_filename) = binding_to_filename.get(ref_binding) {
                    if source_filename == &factory.filename {
                        continue;
                    }
                    imports_by_source
                        .entry(source_filename.clone())
                        .or_default()
                        .push(ref_binding.clone());
                } else if external_imports.contains_key(ref_binding) {
                    external_import_bindings.insert(ref_binding.clone());
                }
            }
            let mut reserved_import_atoms = declared_owned_atoms.clone();
            reserved_import_atoms.extend(owned_export_atoms.iter().cloned());
            reserved_import_atoms
                .extend(factory.write_bindings.iter().map(|(atom, _)| atom.clone()));
            let mut source_filenames: Vec<String> = imports_by_source.keys().cloned().collect();
            source_filenames.sort();
            for source_filename in source_filenames {
                let bindings = imports_by_source.get_mut(&source_filename).unwrap();
                bindings.sort_by(|a, b| a.0.cmp(&b.0));
                bindings.dedup();
                let mut names = Vec::new();
                for binding in bindings {
                    let imported = binding.0.clone();
                    let local = reserve_import_atom(&imported, &mut reserved_import_atoms);
                    if local != imported {
                        import_renames.push(BindingRename {
                            old: binding.clone(),
                            new: local.clone(),
                        });
                    }
                    names.push((imported, local));
                }
                let rel_path = relative_import_path(&factory.filename, &source_filename);
                import_items.push(make_scope_import_stmt_with_aliases(&names, &rel_path));
            }
        }
        let mut external_import_bindings: Vec<BindingId> =
            external_import_bindings.into_iter().collect();
        external_import_bindings.sort_by(|a, b| a.0.cmp(&b.0));
        for binding in external_import_bindings {
            if let Some(import) = external_imports.get(&binding) {
                import_items.push(make_external_import_stmt(import));
            }
        }

        let mut body_items: Vec<ModuleItem> = import_items
            .into_iter()
            .chain(owned_decl_items.clone())
            .chain(factory_owned_export_items(
                &factory.filename,
                &factory_owned_bindings,
            ))
            .collect();
        rename_bindings(&mut body_items, &import_renames);
        let mut factory_body_stmts = factory.body_stmts;
        rename_bindings(&mut factory_body_stmts, &import_renames);

        let mut write_names: Vec<Atom> = factory
            .write_bindings
            .iter()
            .filter(|binding| {
                binding_to_filename
                    .get(*binding)
                    .is_some_and(|filename| filename == &factory.filename)
                    && !declared_owned_atoms.contains(&binding.0)
            })
            .map(|(atom, _)| atom.clone())
            .collect();
        write_names.sort();
        write_names.dedup();

        let mut code = String::new();
        // Other modules may import and call this synthetic init function while
        // this module is still evaluating through an ESM cycle. Keep the
        // module-local storage it mutates before the exported callable wrapper,
        // otherwise later VarDeclToLetConst can turn trailing `var` storage
        // into TDZ-sensitive `let` declarations.
        if !body_items.is_empty() {
            code.push_str(&emit_items(
                body_items,
                factory.filename.clone(),
                cm.clone(),
            ));
        }
        if !write_names.is_empty() {
            let names = write_names
                .iter()
                .map(|name| name.as_ref())
                .collect::<Vec<_>>()
                .join(", ");
            code.push_str(&format!("export var {names};\n"));
        }
        if let Some(cjs_params) = &factory.cjs_params {
            let cache_name = format!("__wakaru_{}_cache", factory.var_name);
            code.push_str(&format!("var {cache_name};\n"));
            code.push_str(&format!("export function {}() {{\n", factory.var_name));
            let cached_return = cjs_params
                .module
                .as_ref()
                .map(|_| format!("{cache_name}.exports"))
                .unwrap_or_else(|| cache_name.clone());
            code.push_str(&format!("if ({cache_name}) return {cached_return};\n"));
            code.push_str(&format!("var {} = {{}};\n", cjs_params.exports));
            if let Some(module_name) = &cjs_params.module {
                code.push_str(&format!(
                    "var {module_name} = {{ exports: {} }};\n",
                    cjs_params.exports
                ));
                code.push_str(&format!("{cache_name} = {module_name};\n"));
            } else {
                code.push_str(&format!("{cache_name} = {};\n", cjs_params.exports));
            }
            code.push_str(&emit_items(
                factory_body_stmts
                    .into_iter()
                    .map(ModuleItem::Stmt)
                    .collect(),
                factory.filename.clone(),
                cm.clone(),
            ));
            let return_expr = cjs_params
                .module
                .as_ref()
                .map(|module_name| format!("{module_name}.exports"))
                .unwrap_or_else(|| cjs_params.exports.to_string());
            code.push_str(&format!("\nreturn {return_expr};\n}}\n"));
        } else {
            code.push_str(&emit_esm_init_function_code(
                &factory.var_name,
                factory_body_stmts,
                factory.filename.clone(),
                cm.clone(),
            ));
        }
        modules.push(UnpackedModule {
            id: factory.var_name.to_string(),
            is_entry: false,
            code,
            filename: factory.filename,
            source_ranges: span_byte_range(&cm, factory.span).into_iter().collect(),
            source_input: String::new(),
            generated_source_map: Vec::new(),
        });
    }

    if !remaining_entry.is_empty() {
        let entry_ranges = spans_byte_ranges(&cm, remaining_entry.iter().map(|item| item.span()));
        let remaining_entry = repair_entry_imports(remaining_entry, &binding_to_filename);
        let entry_module = Module {
            span: Default::default(),
            body: remaining_entry,
            shebang: None,
        };
        let code = emit_module(entry_module, "entry.js".to_string(), cm);
        modules.push(UnpackedModule {
            id: "entry".to_string(),
            is_entry: true,
            code,
            filename: "entry.js".to_string(),
            source_ranges: entry_ranges,
            source_input: String::new(),
            generated_source_map: Vec::new(),
        });
    }

    Some(UnpackResult::without_cycle_premerge(
        modules,
        BundleFormat::Esbuild,
    ))
}

fn emit_esm_init_function_code(
    name: &Atom,
    stmts: Vec<Stmt>,
    filename: String,
    cm: Lrc<SourceMap>,
) -> String {
    let guard = format!("__wakaru_{name}_initialized");
    let body = emit_items(
        stmts.into_iter().map(ModuleItem::Stmt).collect(),
        filename,
        cm,
    );
    format!("var {guard} = false;\nexport function {name}() {{\nif ({guard}) return;\n{guard} = true;\n{body}\n}}\n")
}

fn repair_entry_imports(
    entry_items: Vec<ModuleItem>,
    binding_to_filename: &HashMap<BindingId, String>,
) -> Vec<ModuleItem> {
    repair_module_imports(entry_items, "entry.js", binding_to_filename)
}

fn repair_module_imports(
    mut entry_items: Vec<ModuleItem>,
    current_filename: &str,
    binding_to_filename: &HashMap<BindingId, String>,
) -> Vec<ModuleItem> {
    let candidate_atoms: HashSet<Atom> = binding_to_filename
        .iter()
        .filter(|(_, filename)| filename.as_str() != current_filename)
        .map(|((atom, _), _)| atom.clone())
        .collect();
    if candidate_atoms.is_empty() {
        return entry_items;
    }

    let mut collector = AtomRefCollector {
        candidate_atoms: &candidate_atoms,
        references: HashSet::new(),
        shadowed_atoms: vec![HashSet::new()],
    };
    for item in &entry_items {
        item.visit_with(&mut collector);
    }

    let mut already_imported: HashSet<Atom> = entry_items
        .iter()
        .flat_map(|item| {
            module_item_import_binding_ids(item)
                .into_iter()
                .chain(module_item_declared_binding_ids(item))
        })
        .map(|(atom, _)| atom)
        .collect();
    let binding_filename_by_atom = atom_to_filename_binding_map(binding_to_filename);
    let mut imports_by_source: HashMap<String, Vec<Atom>> = HashMap::new();
    for atom in collector.references {
        if already_imported.contains(&atom) {
            continue;
        }
        let Some((_, source_filename)) = binding_filename_by_atom.get(&atom) else {
            continue;
        };
        if source_filename == current_filename {
            continue;
        }
        let specifier = relative_import_path(current_filename, source_filename);
        imports_by_source
            .entry(specifier)
            .or_default()
            .push(atom.clone());
        already_imported.insert(atom);
    }

    if imports_by_source.is_empty() {
        return entry_items;
    }

    let mut import_items = Vec::new();
    let mut sources: Vec<String> = imports_by_source.keys().cloned().collect();
    sources.sort();
    for source in sources {
        let names = imports_by_source.get_mut(&source).unwrap();
        names.sort();
        names.dedup();
        import_items.push(make_scope_import_stmt(names, &source));
    }
    import_items.append(&mut entry_items);
    import_items
}

fn augment_imports_with_referenced_atoms_for_existing_sources(
    imports_by_source: &mut HashMap<String, Vec<Atom>>,
    current_filename: &str,
    referenced_atoms: &HashSet<Atom>,
    binding_filename_by_atom: &HashMap<Atom, (BindingId, String)>,
    local_atoms: Option<&HashSet<Atom>>,
) {
    for atom in referenced_atoms {
        if local_atoms.is_some_and(|atoms| atoms.contains(atom)) {
            continue;
        }
        let Some((source_binding, source_filename)) = binding_filename_by_atom.get(atom) else {
            continue;
        };
        if source_filename == current_filename || !imports_by_source.contains_key(source_filename) {
            continue;
        }
        imports_by_source
            .entry(source_filename.clone())
            .or_default()
            .push(source_binding.0.clone());
    }
}

fn atom_to_filename_binding_map(
    bindings: &HashMap<BindingId, String>,
) -> HashMap<Atom, (BindingId, String)> {
    let mut by_atom = HashMap::new();
    for (binding, filename) in bindings {
        by_atom
            .entry(binding.0.clone())
            .or_insert_with(|| (binding.clone(), filename.clone()));
    }
    by_atom
}

fn atom_binding_map_from_keys<T>(imports: &HashMap<BindingId, T>) -> HashMap<Atom, BindingId> {
    let mut by_atom = HashMap::new();
    for binding in imports.keys() {
        by_atom
            .entry(binding.0.clone())
            .or_insert_with(|| binding.clone());
    }
    by_atom
}

fn add_factory_atom_import(
    imports_by_filename: &mut HashMap<String, Vec<BindingId>>,
    current_filename: &str,
    source_binding: &BindingId,
    source_filename: &str,
) {
    if source_filename == current_filename {
        return;
    }
    imports_by_filename
        .entry(source_filename.to_string())
        .or_default()
        .push(source_binding.clone());
}

fn atom_to_module_binding_map(
    bindings: &HashMap<BindingId, usize>,
) -> HashMap<Atom, (BindingId, usize)> {
    let mut by_atom = HashMap::new();
    for (binding, module_index) in bindings {
        by_atom
            .entry(binding.0.clone())
            .or_insert_with(|| (binding.clone(), *module_index));
    }
    by_atom
}

// ---------------------------------------------------------------------------
// Extracted factory info
// ---------------------------------------------------------------------------

struct Factory {
    /// Lazy helper used by this factory declaration.
    helper_sym: Atom,
    /// Resolved top-level binding for the factory variable.
    binding: BindingId,
    /// The declared variable name (e.g. `BO7`).
    var_name: Atom,
    /// Derived filename: filepath string key when available, else `<var_name>.js`.
    filename: String,
    /// CommonJS factory callback params: `(exports, module) => { ... }`.
    cjs_params: Option<CjsFactoryParams>,
    /// The statements inside the factory function body (unresolved — for emission).
    body_stmts: Vec<Stmt>,
    /// The statements inside the factory function body (resolved — for reference collection).
    analysis_body_stmts: Vec<Stmt>,
    /// Span of the factory's `var` declarator in the original bundle (provenance).
    span: Span,
}

#[derive(Clone)]
struct CjsFactoryParams {
    exports: Atom,
    module: Option<Atom>,
}

// ---------------------------------------------------------------------------
// Helper detection
//
// esbuild emits lazy-module helpers as top-level `var` declarations whose RHS
// is an arrow function that takes ≤2 params and *returns* another function
// (either an arrow or a named `function` expression).  Both minified and
// non-minified forms share this shape:
//
//   Minified:     (q, K) => () => ...
//   Non-minified: (cb, mod) => function __require() { ... }
// ---------------------------------------------------------------------------

fn collect_helper_syms(module: &Module) -> HashSet<Atom> {
    let mut syms = HashSet::new();
    for item in &module.body {
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
            continue;
        };
        for decl in &var.decls {
            let Some(init) = &decl.init else { continue };
            if is_lazy_helper(init) {
                if let Pat::Ident(bi) = &decl.name {
                    syms.insert(bi.id.sym.clone());
                }
            }
        }
    }
    syms
}

fn collect_commonjs_helper_syms(module: &Module) -> HashSet<Atom> {
    let mut syms = HashSet::new();
    for item in &module.body {
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
            continue;
        };
        for decl in &var.decls {
            let Some(init) = &decl.init else { continue };
            if is_lazy_helper(init) && expr_mentions_exports_member(init) {
                if let Pat::Ident(bi) = &decl.name {
                    syms.insert(bi.id.sym.clone());
                }
            }
        }
    }
    syms
}

/// Returns `true` if `expr` matches the esbuild lazy-helper shape:
///   Arrow(≤2 params) → body is Arrow or named Fn expression
fn is_lazy_helper(expr: &Expr) -> bool {
    let Expr::Arrow(outer) = expr else {
        return false;
    };
    if outer.params.len() > 2 {
        return false;
    }
    let body_expr = match &*outer.body {
        BlockStmtOrExpr::Expr(e) => e,
        BlockStmtOrExpr::BlockStmt(_) => return false,
    };
    matches!(**body_expr, Expr::Arrow(_) | Expr::Fn(_))
}

fn expr_mentions_exports_member(expr: &Expr) -> bool {
    struct ExportsMemberVisitor {
        found: bool,
    }

    impl Visit for ExportsMemberVisitor {
        fn visit_member_expr(&mut self, expr: &swc_core::ecma::ast::MemberExpr) {
            if self.found {
                return;
            }
            if let swc_core::ecma::ast::MemberProp::Ident(prop) = &expr.prop {
                if prop.sym == *"exports" {
                    self.found = true;
                    return;
                }
            }
            expr.obj.visit_with(self);
            if let swc_core::ecma::ast::MemberProp::Computed(c) = &expr.prop {
                c.visit_with(self);
            }
        }

        fn visit_prop_name(&mut self, name: &PropName) {
            if self.found {
                return;
            }
            match name {
                PropName::Ident(id) if id.sym == *"exports" => {
                    self.found = true;
                }
                PropName::Computed(c) => c.visit_with(self),
                _ => {}
            }
        }
    }

    let mut visitor = ExportsMemberVisitor { found: false };
    expr.visit_with(&mut visitor);
    visitor.found
}

// ---------------------------------------------------------------------------
// Factory collection
//
// A factory is a top-level `var X = helper(fn_or_obj)` where `helper` is one
// of the detected lazy-helper symbols.
//
// Non-minified form uses an object literal whose key is the original file path:
//   var require_foo = __commonJS({ "src/foo.js"(exports, module) { … } })
//
// Minified form uses a plain arrow/function:
//   var BO7 = y(() => { … })
// ---------------------------------------------------------------------------

struct PathCommentHints<'a> {
    source: &'a str,
    source_start_pos: u32,
    hints: Vec<(usize, String)>,
}

impl<'a> PathCommentHints<'a> {
    fn new(source: &'a str, source_start_pos: u32) -> Self {
        let mut hints = Vec::new();
        let mut offset = 0usize;
        for line in source.split_inclusive('\n') {
            let text = line.trim_end_matches(['\r', '\n']);
            if let Some(path) = parse_path_comment(text) {
                hints.push((offset + line.len(), sanitize_path_comment_hint(path)));
            }
            offset += line.len();
        }
        Self {
            source,
            source_start_pos,
            hints,
        }
    }

    fn hint_before(&self, abs_byte_pos: u32) -> Option<String> {
        let rel = abs_byte_pos.checked_sub(self.source_start_pos)? as usize;
        if rel > self.source.len() {
            return None;
        }
        let (code_start, filename) = self
            .hints
            .iter()
            .rev()
            .find(|(code_start, _)| *code_start <= rel)?;
        if self.source[*code_start..rel].trim().is_empty() {
            Some(filename.clone())
        } else {
            None
        }
    }
}

fn parse_path_comment(line: &str) -> Option<String> {
    let path = line.trim_start().strip_prefix("// ")?;
    if path.starts_with('#') || path.starts_with("===") {
        return None;
    }
    let normalized = path.replace('\\', "/");
    let lower = normalized.to_ascii_lowercase();
    let valid_ext = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]
        .iter()
        .any(|ext| lower.ends_with(ext));
    valid_ext.then_some(normalized)
}

fn sanitize_path_comment_hint(path: String) -> String {
    let mut path = sanitize_path(path);
    if let Some(dot) = path.rfind('.') {
        path.replace_range(dot.., ".js");
    } else {
        path.push_str(".js");
    }
    path
}

fn collect_factories(
    module: &Module,
    analysis_module: &Module,
    helper_syms: &HashSet<Atom>,
    commonjs_helper_syms: &HashSet<Atom>,
    filename_hints: Option<&PathCommentHints<'_>>,
) -> Vec<Factory> {
    let mut factories = Vec::new();
    for (item, analysis_item) in module.body.iter().zip(analysis_module.body.iter()) {
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
            continue;
        };
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(analysis_var))) = analysis_item else {
            continue;
        };
        for (decl, analysis_decl) in var.decls.iter().zip(analysis_var.decls.iter()) {
            if let Some(factory) = try_extract_factory(
                decl,
                analysis_decl,
                var.span.lo.0,
                helper_syms,
                commonjs_helper_syms,
                filename_hints,
            ) {
                factories.push(factory);
            }
        }
    }
    factories
}

fn try_extract_factory(
    decl: &VarDeclarator,
    analysis_decl: &VarDeclarator,
    decl_start_abs: u32,
    helper_syms: &HashSet<Atom>,
    commonjs_helper_syms: &HashSet<Atom>,
    filename_hints: Option<&PathCommentHints<'_>>,
) -> Option<Factory> {
    let Pat::Ident(var_ident) = &decl.name else {
        return None;
    };
    let init = decl.init.as_ref()?;
    let Expr::Call(call) = &**init else {
        return None;
    };

    // Callee must be one of the detected helpers.
    let helper_sym = call_target_helper_sym(call, helper_syms)?;
    let is_commonjs_factory = commonjs_helper_syms.contains(&helper_sym);

    if call.args.len() != 1 {
        return None;
    }

    let arg = &*call.args[0].expr;
    let var_name = var_ident.id.sym.clone();
    let hinted_filename = filename_hints.and_then(|hints| hints.hint_before(decl_start_abs));
    let binding = match &analysis_decl.name {
        Pat::Ident(bi) => (bi.id.sym.clone(), bi.id.ctxt),
        _ => return None,
    };

    // Extract analysis (resolved) body stmts in parallel.
    let analysis_arg = analysis_decl.init.as_ref().and_then(|init| match &**init {
        Expr::Call(c) if c.args.len() == 1 => Some(&*c.args[0].expr),
        _ => None,
    });

    match arg {
        // Non-minified: __commonJS({ "src/foo.js"(exports, module) { … } })
        Expr::Object(obj) if obj.props.len() == 1 => {
            use swc_core::ecma::ast::{Prop, PropOrSpread};
            if let PropOrSpread::Prop(prop) = &obj.props[0] {
                if let Prop::Method(method) = &**prop {
                    let filename = prop_key_str(&method.key)
                        .map(sanitize_path)
                        .or_else(|| hinted_filename.clone())
                        .unwrap_or_else(|| format!("{var_name}.js"));
                    let body_stmts = method.function.body.as_ref()?.stmts.clone();
                    let analysis_body_stmts = extract_analysis_body_stmts_obj(analysis_arg)
                        .unwrap_or_else(|| body_stmts.clone());
                    return Some(Factory {
                        helper_sym,
                        binding,
                        var_name,
                        filename,
                        cjs_params: is_commonjs_factory
                            .then(|| function_cjs_params(&method.function))
                            .flatten(),
                        body_stmts,
                        analysis_body_stmts,
                        span: decl.span,
                    });
                }
            }
            None
        }

        // Minified arrow: y(() => { … }) or y(() => expr)
        Expr::Arrow(arrow) => {
            let body_stmts = arrow_body_stmts(arrow);
            let analysis_body_stmts = analysis_arg
                .and_then(|a| match a {
                    Expr::Arrow(aa) => Some(arrow_body_stmts(aa)),
                    _ => None,
                })
                .unwrap_or_else(|| body_stmts.clone());
            let filename = hinted_filename.unwrap_or_else(|| format!("{var_name}.js"));
            Some(Factory {
                helper_sym,
                binding,
                var_name,
                filename,
                cjs_params: is_commonjs_factory
                    .then(|| arrow_cjs_params(arrow))
                    .flatten(),
                body_stmts,
                analysis_body_stmts,
                span: decl.span,
            })
        }

        // Minified function: m(function() { … })
        Expr::Fn(fn_expr) => {
            let body_stmts = fn_expr.function.body.as_ref()?.stmts.clone();
            let analysis_body_stmts = analysis_arg
                .and_then(|a| match a {
                    Expr::Fn(af) => af.function.body.as_ref().map(|b| b.stmts.clone()),
                    _ => None,
                })
                .unwrap_or_else(|| body_stmts.clone());
            let filename = hinted_filename.unwrap_or_else(|| format!("{var_name}.js"));
            Some(Factory {
                helper_sym,
                binding,
                var_name,
                filename,
                cjs_params: is_commonjs_factory
                    .then(|| function_cjs_params(&fn_expr.function))
                    .flatten(),
                body_stmts,
                analysis_body_stmts,
                span: decl.span,
            })
        }

        _ => None,
    }
}

/// Extract resolved body stmts from an analysis object-form factory argument.
fn extract_analysis_body_stmts_obj(analysis_arg: Option<&Expr>) -> Option<Vec<Stmt>> {
    let Expr::Object(obj) = analysis_arg? else {
        return None;
    };
    if obj.props.len() != 1 {
        return None;
    }
    let swc_core::ecma::ast::PropOrSpread::Prop(prop) = &obj.props[0] else {
        return None;
    };
    let swc_core::ecma::ast::Prop::Method(method) = &**prop else {
        return None;
    };
    method.function.body.as_ref().map(|b| b.stmts.clone())
}

fn arrow_cjs_params(arrow: &ArrowExpr) -> Option<CjsFactoryParams> {
    if arrow.params.is_empty() {
        return None;
    }
    let exports_name = pat_ident_atom(&arrow.params[0])?;
    let module_name = arrow.params.get(1).and_then(pat_ident_atom);
    Some(CjsFactoryParams {
        exports: exports_name,
        module: module_name,
    })
}

fn function_cjs_params(function: &Function) -> Option<CjsFactoryParams> {
    if function.params.is_empty() {
        return None;
    }
    let exports_name = pat_ident_atom(&function.params[0].pat)?;
    let module_name = function
        .params
        .get(1)
        .and_then(|param| pat_ident_atom(&param.pat));
    Some(CjsFactoryParams {
        exports: exports_name,
        module: module_name,
    })
}

fn pat_ident_atom(pat: &Pat) -> Option<Atom> {
    match pat {
        Pat::Ident(ident) => Some(ident.id.sym.clone()),
        _ => None,
    }
}

fn call_target_helper_sym(call: &CallExpr, helper_syms: &HashSet<Atom>) -> Option<Atom> {
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let Expr::Ident(ident) = &**callee else {
        return None;
    };
    if helper_syms.contains(&ident.sym) {
        Some(ident.sym.clone())
    } else {
        None
    }
}

fn arrow_body_stmts(arrow: &ArrowExpr) -> Vec<Stmt> {
    match &*arrow.body {
        BlockStmtOrExpr::BlockStmt(block) => block.stmts.clone(),
        BlockStmtOrExpr::Expr(expr) => vec![Stmt::Expr(ExprStmt {
            span: Default::default(),
            expr: expr.clone(),
        })],
    }
}

fn prop_key_str(key: &swc_core::ecma::ast::PropName) -> Option<String> {
    use swc_core::ecma::ast::PropName;
    match key {
        PropName::Str(Str { value, .. }) => Some(value.as_str().unwrap_or("").to_string()),
        PropName::Ident(id) => Some(id.sym.to_string()),
        _ => None,
    }
}

/// Convert a source-map style path (`../src/foo.js`, `webpack:///src/foo.js`) to a
/// safe relative path suitable as a filename.
fn sanitize_path(raw: String) -> String {
    let s = raw
        .trim_start_matches("webpack://")
        .trim_start_matches("webpack:///")
        .trim_start_matches('/');
    crate::unpacker::sanitize_relative_path(s, "module.js")
}

fn filter_helper_factory_declarators(
    item: &ModuleItem,
    helper_factory_syms: &HashSet<Atom>,
) -> Option<ModuleItem> {
    let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = item else {
        return Some(item.clone());
    };
    let mut filtered = var_decl.clone();
    filtered.decls.retain(|decl| {
        !matches!(
            &decl.name,
            Pat::Ident(bi) if helper_factory_syms.contains(&bi.id.sym)
        )
    });
    if filtered.decls.is_empty() {
        None
    } else {
        Some(ModuleItem::Stmt(Stmt::Decl(Decl::Var(filtered))))
    }
}

fn item_has_helper_factory_declarator(
    item: &ModuleItem,
    helper_factory_syms: &HashSet<Atom>,
) -> bool {
    let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = item else {
        return false;
    };
    var_decl.decls.iter().any(|decl| {
        matches!(
            &decl.name,
            Pat::Ident(bi) if helper_factory_syms.contains(&bi.id.sym)
        )
    })
}

// ---------------------------------------------------------------------------
// Scope-hoisted module extraction
//
// esbuild scope-hoists ESM modules into a flat top-level scope. Each
// scope-hoisted module is marked by:
//
//   var NS = {};
//   __export(NS, { exportName: () => localBinding, ... });
//   ... module code (var/function/class declarations) ...
//
// The `__export` helper is an arrow:
//   (target, all) => { for (var name in all) defProp(target, name, {get: all[name], ...}) }
//
// KNOWN LIMITATION (last-module boundary):
// For non-last modules, the next `var NS = {}; __export(NS, ...)` boundary
// cleanly delimits module code. For the last module, we use a three-phase
// heuristic: Phase 1 finds the last exported-binding declaration, Phase 2
// extends via reference closure (private helpers after exports), Phase 3
// includes trailing expression statements that reference module bindings.
//
// This can misattribute entry-level expressions that reference bindings
// from the last module. For example:
//   // constants.js (module side effect)
//   console.log(LABEL, VALUE);
//   // entry.js (entry code referencing same binding)
//   console.log("entry", VALUE);
//
// Both appear after the last export and reference `VALUE`. In minified
// production bundles there is no structural marker distinguishing them —
// the ambiguity is inherent. The misattribution is cosmetic (code lands
// in the wrong file) not functional (bindings remain accessible in the
// shared scope).
//
// We detect this helper, find all namespace+export pairs, and partition
// the top-level items into per-module groups.
// ---------------------------------------------------------------------------

/// Metadata collected during the first pass over scope-hoisted boundaries.
#[derive(Clone)]
struct ScopeNamespaceExport {
    namespace_binding: BindingId,
    export_entries: Vec<(Atom, BindingId)>,
}

#[derive(Clone)]
struct ScopeModuleMeta {
    namespaces: Vec<ScopeNamespaceExport>,
    body_indices: Vec<usize>,
    owned_support_bindings: HashSet<BindingId>,
    exported_bindings: HashSet<BindingId>,
    exported_atoms: HashSet<Atom>,
    declared_bindings: HashSet<BindingId>,
    local_import_bindings: HashSet<BindingId>,
    referenced_bindings: HashSet<BindingId>,
    written_atoms: HashSet<Atom>,
    referenced_atoms: HashSet<Atom>,
    filename: String,
    id: String,
}

struct ScopeExtractionRefs<'a> {
    factory_referenced: &'a HashSet<BindingId>,
    factory_preassigned_bindings: &'a HashMap<BindingId, String>,
    factory_importable_bindings: &'a HashMap<BindingId, String>,
    drop_unowned_helper_sibling_indices: &'a HashSet<usize>,
}

fn merge_conflicting_factory_scope_metas(
    metas: &mut Vec<ScopeModuleMeta>,
    factory_preassigned_by_atom: &HashMap<Atom, (BindingId, String)>,
) {
    if metas.len() < 2 {
        return;
    }

    // A lazy init factory can seed mutable bindings that are later assigned by
    // different scope modules. Those modules must stay in one synthetic ESM
    // file with the factory, otherwise one writer would assign to an import.
    let mut writer_modules_by_factory: HashMap<String, Vec<usize>> = HashMap::new();
    for (mi, meta) in metas.iter().enumerate() {
        let mut factories = HashSet::new();
        for atom in &meta.written_atoms {
            let Some((_, factory_filename)) = factory_preassigned_by_atom.get(atom) else {
                continue;
            };
            if *factory_filename != meta.filename {
                factories.insert(factory_filename.clone());
            }
        }
        for factory_filename in factories {
            writer_modules_by_factory
                .entry(factory_filename)
                .or_default()
                .push(mi);
        }
    }

    let mut adjacency: Vec<HashSet<usize>> = vec![HashSet::new(); metas.len()];
    for writers in writer_modules_by_factory.values_mut() {
        writers.sort_unstable();
        writers.dedup();
        if writers.len() < 2 {
            continue;
        }
        let first = writers[0];
        for &writer in &writers[1..] {
            adjacency[first].insert(writer);
            adjacency[writer].insert(first);
        }
    }

    if adjacency.iter().all(HashSet::is_empty) {
        return;
    }

    let mut group_by_first: HashMap<usize, Vec<usize>> = HashMap::new();
    let mut member_to_first: HashMap<usize, usize> = HashMap::new();
    let mut visited = vec![false; metas.len()];
    for start in 0..metas.len() {
        if visited[start] {
            continue;
        }
        let mut stack = vec![start];
        let mut group = Vec::new();
        visited[start] = true;
        while let Some(current) = stack.pop() {
            group.push(current);
            for &next in &adjacency[current] {
                if visited[next] {
                    continue;
                }
                visited[next] = true;
                stack.push(next);
            }
        }
        if group.len() < 2 {
            continue;
        }
        group.sort_unstable();
        let first = group[0];
        for &member in &group {
            member_to_first.insert(member, first);
        }
        group_by_first.insert(first, group);
    }

    if group_by_first.is_empty() {
        return;
    }

    let original = metas.clone();
    let mut merged = Vec::new();
    for index in 0..original.len() {
        if member_to_first
            .get(&index)
            .is_some_and(|first| *first != index)
        {
            continue;
        }
        if let Some(group) = group_by_first.get(&index) {
            merged.push(merge_scope_meta_group(&original, group));
        } else {
            merged.push(original[index].clone());
        }
    }
    *metas = merged;
}

fn merge_scope_meta_group(metas: &[ScopeModuleMeta], group: &[usize]) -> ScopeModuleMeta {
    let mut merged = metas[group[0]].clone();
    for &index in &group[1..] {
        let meta = &metas[index];
        merged.namespaces.extend(meta.namespaces.clone());
        merged
            .body_indices
            .extend(meta.body_indices.iter().copied());
        merged
            .owned_support_bindings
            .extend(meta.owned_support_bindings.iter().cloned());
        merged
            .exported_bindings
            .extend(meta.exported_bindings.iter().cloned());
        merged
            .exported_atoms
            .extend(meta.exported_atoms.iter().cloned());
        merged
            .declared_bindings
            .extend(meta.declared_bindings.iter().cloned());
        merged
            .local_import_bindings
            .extend(meta.local_import_bindings.iter().cloned());
        merged
            .referenced_bindings
            .extend(meta.referenced_bindings.iter().cloned());
        merged
            .written_atoms
            .extend(meta.written_atoms.iter().cloned());
        merged
            .referenced_atoms
            .extend(meta.referenced_atoms.iter().cloned());
    }
    merged.body_indices.sort_unstable();
    merged.body_indices.dedup();
    merged
}

/// Extract scope-hoisted modules from entry items.
/// Returns (extracted_modules, remaining_entry_items, binding_to_filename).
///
/// After partitioning items into per-module groups, this function
/// synthesizes ES import/export statements so that cross-module
/// references (which the bundler resolved via direct bindings) are
/// represented as standard module edges.
///
/// `seen_lower` is the shared case-insensitive filename set, already
/// populated by factory modules.  Scope-hoisted filenames are probed
/// against it so they never collide with factories or each other.
///
/// `factory_referenced` contains all bindings referenced by factory modules.
/// These are included in export expansion so scope-hoisted modules export
/// bindings that factories need.  The returned `binding_to_filename` map
/// lets callers synthesize imports in factory modules.
fn extract_scope_hoisted_modules(
    analysis_items: &[ModuleItem],
    source_items: Vec<ModuleItem>,
    seen_lower: &mut HashSet<String>,
    cm: Lrc<SourceMap>,
    refs: ScopeExtractionRefs<'_>,
) -> (
    Vec<UnpackedModule>,
    Vec<ModuleItem>,
    HashMap<BindingId, String>,
    HashMap<String, HashSet<BindingId>>,
    HashMap<String, HashSet<Atom>>,
    HashMap<String, HashSet<Atom>>,
    HashMap<BindingId, String>,
) {
    debug_assert_eq!(analysis_items.len(), source_items.len());
    let ScopeExtractionRefs {
        factory_referenced,
        factory_preassigned_bindings,
        factory_importable_bindings,
        drop_unowned_helper_sibling_indices,
    } = refs;

    let span = tracing::info_span!("esbuild: scope collect metadata");
    let metadata_enter = span.enter();

    // Step 1: find the __export helper binding.
    let Some((export_helper_index, export_helper)) = detect_export_helper(analysis_items) else {
        return (
            vec![],
            source_items,
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
        );
    };
    let item_infos = build_item_binding_infos(analysis_items);
    let top_level_bindings: HashSet<BindingId> = item_infos
        .iter()
        .flat_map(|info| info.declared.iter().cloned())
        .chain(
            analysis_items
                .iter()
                .flat_map(|item| module_item_import_binding_ids(item).into_iter()),
        )
        .collect();
    let top_level_atoms: HashSet<Atom> = top_level_bindings
        .iter()
        .map(|(atom, _)| atom.clone())
        .collect();
    let external_imports = collect_external_imports(analysis_items, &source_items);

    // Step 2: find all (namespace_decl_index, export_call_index, ns_atom) triples.
    let boundaries = collect_scope_hoisted_boundaries(analysis_items, &export_helper);
    if boundaries.is_empty() {
        return (
            vec![],
            source_items,
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
            HashMap::new(),
        );
    }
    drop(metadata_enter);

    // Convert to Option<ModuleItem> so items can be moved out by index.
    let mut source_slots: Vec<Option<ModuleItem>> = source_items.into_iter().map(Some).collect();
    let original_source_items: Vec<ModuleItem> = source_slots
        .iter()
        .map(|item| item.as_ref().expect("source slot should exist").clone())
        .collect();

    // Step 3 (pass 1): partition items and collect per-module metadata.
    let span = tracing::info_span!("esbuild: scope partition modules", count = boundaries.len());
    let partition_enter = span.enter();
    let mut metas: Vec<ScopeModuleMeta> = Vec::new();
    let mut consumed: HashSet<usize> = HashSet::new();
    let scope_candidate_atoms: HashSet<Atom> = item_infos
        .iter()
        .flat_map(|info| info.declared.iter().map(|(atom, _)| atom.clone()))
        .collect();
    let factory_preassigned_set: HashSet<BindingId> =
        factory_preassigned_bindings.keys().cloned().collect();
    let factory_preassigned_atoms: HashSet<Atom> = factory_preassigned_bindings
        .keys()
        .map(|(atom, _)| atom.clone())
        .collect();
    let mut reference_candidate_atoms = scope_candidate_atoms.clone();
    reference_candidate_atoms.extend(factory_preassigned_atoms.iter().cloned());
    reference_candidate_atoms.extend(
        factory_importable_bindings
            .keys()
            .map(|(atom, _)| atom.clone()),
    );

    // Track consumed namespace bindings so we can restore them for the entry.
    let mut consumed_ns: Vec<(usize, usize, &ScopeHoistedBoundary)> = Vec::new();

    let removable_export_helper_indices = removable_export_helper_dependency_indices(
        export_helper_index,
        analysis_items,
        &item_infos,
        &boundaries,
    );
    consumed.extend(removable_export_helper_indices.iter().copied());

    // Collect all factory-referenced atoms (not BindingIds) so we can use
    // them when finding the last module's end boundary.  This ensures private
    // helpers only referenced by factories are absorbed into the scope-hoisted
    // module rather than leaking into entry.js.
    let factory_referenced_atoms: HashSet<Atom> = factory_referenced
        .iter()
        .map(|(atom, _)| atom.clone())
        .collect();

    for (bi, boundary) in boundaries.iter().enumerate() {
        let start = boundary.ns_decl_index;
        let end = if bi + 1 < boundaries.len() {
            boundaries[bi + 1].ns_decl_index
        } else {
            find_last_module_end(
                analysis_items,
                &item_infos,
                boundary.export_call_index + 1,
                &boundary.exported_bindings,
                &factory_referenced_atoms,
            )
        };

        let mut body_indices: Vec<usize> = Vec::new();
        let mut declared_bindings: HashSet<BindingId> = HashSet::new();
        let mut local_import_bindings: HashSet<BindingId> = HashSet::new();
        let mut referenced_bindings: HashSet<BindingId> = HashSet::new();
        let mut written_atoms: HashSet<Atom> = HashSet::new();
        let mut referenced_atoms: HashSet<Atom> = HashSet::new();

        for i in start..end {
            consumed.insert(i);
            if i == boundary.ns_decl_index || i == boundary.export_call_index {
                continue;
            }
            let item_needs_filtering = item_infos[i].declared.iter().any(|id| {
                factory_preassigned_set.contains(id) || factory_preassigned_atoms.contains(&id.0)
            });
            let mut filtered_analysis_item = None;
            let mut filtered_info = None;
            if item_needs_filtering {
                let Some(item) = filter_item_excluding_bindings(
                    &analysis_items[i],
                    &factory_preassigned_set,
                    &factory_preassigned_atoms,
                ) else {
                    continue;
                };
                let filtered_source_item = source_slots[i]
                    .as_ref()
                    .and_then(|source_item| {
                        filter_item_excluding_bindings(
                            source_item,
                            &factory_preassigned_set,
                            &factory_preassigned_atoms,
                        )
                    })
                    .expect("source item should filter with analysis item");
                source_slots[i] = Some(filtered_source_item);
                filtered_info = Some(item_binding_info_for(&item, &top_level_bindings));
                filtered_analysis_item = Some(item);
            }
            let analysis_item_for_visits = filtered_analysis_item
                .as_ref()
                .unwrap_or(&analysis_items[i]);
            let info = filtered_info.as_ref().unwrap_or(&item_infos[i]);

            let mut atom_collector = AtomRefCollector {
                candidate_atoms: &reference_candidate_atoms,
                references: HashSet::new(),
                shadowed_atoms: vec![HashSet::new()],
            };
            analysis_item_for_visits.visit_with(&mut atom_collector);
            body_indices.push(i);
            declared_bindings.extend(info.declared.iter().cloned());
            local_import_bindings.extend(module_item_import_binding_ids(analysis_item_for_visits));
            referenced_bindings.extend(info.references.iter().cloned());
            written_atoms.extend(scope_write_atoms_for_item(
                analysis_item_for_visits,
                &top_level_bindings,
                &top_level_atoms,
            ));
            referenced_atoms.extend(atom_collector.references);
        }

        consumed_ns.push((boundary.ns_decl_index, boundary.export_call_index, boundary));

        if body_indices.is_empty() {
            continue;
        }

        let exported_atoms: HashSet<Atom> = boundary
            .exported_bindings
            .iter()
            .map(|(atom, _)| atom.clone())
            .collect();

        let base_name = boundary.ns_atom.to_string();
        let filename = dedup_filename(&format!("{base_name}.js"), seen_lower);
        let id = filename
            .strip_suffix(".js")
            .unwrap_or(&filename)
            .to_string();

        metas.push(ScopeModuleMeta {
            namespaces: vec![ScopeNamespaceExport {
                namespace_binding: boundary.ns_binding.clone(),
                export_entries: boundary.export_entries.clone(),
            }],
            body_indices,
            owned_support_bindings: HashSet::new(),
            exported_bindings: boundary.exported_bindings.clone(),
            exported_atoms,
            declared_bindings,
            local_import_bindings,
            referenced_bindings,
            written_atoms,
            referenced_atoms,
            filename,
            id,
        });
    }
    drop(partition_enter);

    let span = tracing::info_span!("esbuild: scope build binding maps", count = metas.len());
    let binding_maps_enter = span.enter();
    let factory_preassigned_by_atom = atom_to_filename_binding_map(factory_preassigned_bindings);
    merge_conflicting_factory_scope_metas(&mut metas, &factory_preassigned_by_atom);

    // Build binding → module index map for all scope-hoisted modules.
    let mut binding_to_module: HashMap<BindingId, usize> = HashMap::new();
    let mut module_local_atoms: HashMap<String, HashSet<Atom>> = HashMap::new();
    for (mi, meta) in metas.iter().enumerate() {
        for namespace in &meta.namespaces {
            binding_to_module.insert(namespace.namespace_binding.clone(), mi);
        }
        for binding in &meta.declared_bindings {
            binding_to_module.insert(binding.clone(), mi);
        }
    }

    let decl_index_by_binding: HashMap<BindingId, usize> = item_infos
        .iter()
        .enumerate()
        .flat_map(|(index, info)| {
            info.declared
                .iter()
                .cloned()
                .map(move |binding| (binding, index))
        })
        .collect();
    drop(binding_maps_enter);

    // Scope-hoisted modules often call small top-level helpers that sit before
    // the namespace block. Move safe helper-like declarations into the first
    // extracted module that needs them so generated modules don't reference
    // invisible bindings left behind in entry.js.
    let span = tracing::info_span!("esbuild: scope adopt support decls");
    let support_enter = span.enter();
    let mut owned_support_by_index: HashMap<usize, HashSet<BindingId>> = HashMap::new();
    for (mi, meta) in metas.iter_mut().enumerate() {
        let module_start = meta
            .body_indices
            .iter()
            .min()
            .copied()
            .unwrap_or(usize::MAX);
        let mut queue: Vec<BindingId> = meta
            .referenced_bindings
            .iter()
            .chain(meta.exported_bindings.iter())
            .cloned()
            .collect();
        while let Some(binding) = queue.pop() {
            if meta.declared_bindings.contains(&binding)
                || binding_to_module.contains_key(&binding)
                || factory_preassigned_bindings.contains_key(&binding)
                || factory_importable_bindings.contains_key(&binding)
                || external_imports.contains_key(&binding)
                || meta.local_import_bindings.contains(&binding)
            {
                continue;
            }

            let Some(&decl_index) = decl_index_by_binding.get(&binding) else {
                continue;
            };
            if consumed.contains(&decl_index)
                || decl_index >= module_start
                || !is_scope_support_declaration_for_binding(&analysis_items[decl_index], &binding)
            {
                continue;
            }

            binding_to_module.insert(binding.clone(), mi);
            meta.declared_bindings.insert(binding.clone());
            meta.owned_support_bindings.insert(binding.clone());
            owned_support_by_index
                .entry(decl_index)
                .or_default()
                .insert(binding.clone());

            for ref_binding in &item_infos[decl_index].references {
                if meta.referenced_bindings.insert(ref_binding.clone()) {
                    queue.push(ref_binding.clone());
                }
            }

            let mut atom_collector = AtomRefCollector {
                candidate_atoms: &reference_candidate_atoms,
                references: HashSet::new(),
                shadowed_atoms: vec![HashSet::new()],
            };
            analysis_items[decl_index].visit_with(&mut atom_collector);
            meta.referenced_atoms.extend(atom_collector.references);
        }
    }

    for (index, owned) in &owned_support_by_index {
        let owned_atoms: HashSet<Atom> = owned.iter().map(|(atom, _)| atom.clone()).collect();
        if let Some(item) = source_slots[*index].take() {
            source_slots[*index] = filter_item_excluding_bindings(&item, owned, &owned_atoms);
        }
        if source_slots[*index].is_none() {
            consumed.insert(*index);
        }
    }
    for index in drop_unowned_helper_sibling_indices {
        if source_slots.get(*index).and_then(Option::as_ref).is_some() {
            source_slots[*index] = None;
            consumed.insert(*index);
        }
    }
    drop(support_enter);

    let span = tracing::info_span!("esbuild: scope compute imports exports");
    let imports_exports_enter = span.enter();
    let binding_module_by_atom = atom_to_module_binding_map(&binding_to_module);

    // Collect remaining entry references early so they feed into the
    // effective-export expansion below.
    let remaining_indices: Vec<usize> = (0..source_slots.len())
        .filter(|i| !consumed.contains(i))
        .collect();

    let mut entry_referenced: HashSet<BindingId> = HashSet::new();
    for &i in &remaining_indices {
        entry_referenced.extend(item_infos[i].references.iter().cloned());
    }
    for &(ns_idx, call_idx, _) in &consumed_ns {
        entry_referenced.extend(item_infos[ns_idx].references.iter().cloned());
        entry_referenced.extend(item_infos[call_idx].references.iter().cloned());
    }

    // Expand export sets: the T8-registered exports are the module's public
    // API, but the bundler's scope hoisting lets other modules directly
    // reference private helpers too.  Any declared binding referenced from
    // outside (by another module OR by the entry) must be exported.
    let mut effective_exports: Vec<HashSet<Atom>> =
        metas.iter().map(|m| m.exported_atoms.clone()).collect();
    for (mi, meta) in metas.iter().enumerate() {
        for ref_binding in &meta.referenced_bindings {
            if meta.declared_bindings.contains(ref_binding) {
                continue;
            }
            if let Some(&source_mi) = binding_to_module.get(ref_binding) {
                if source_mi != mi {
                    effective_exports[source_mi].insert(ref_binding.0.clone());
                }
            }
        }
        for export_binding in &meta.exported_bindings {
            if meta.declared_bindings.contains(export_binding) {
                continue;
            }
            if let Some(&source_mi) = binding_to_module.get(export_binding) {
                if source_mi != mi {
                    effective_exports[source_mi].insert(export_binding.0.clone());
                }
            }
        }
    }
    for ref_binding in &entry_referenced {
        if let Some(&source_mi) = binding_to_module.get(ref_binding) {
            effective_exports[source_mi].insert(ref_binding.0.clone());
        }
    }
    // Also expand for references from factory modules.
    for ref_binding in factory_referenced {
        if let Some(&source_mi) = binding_to_module.get(ref_binding) {
            effective_exports[source_mi].insert(ref_binding.0.clone());
        }
    }

    let mut claimed_factory_filenames: HashMap<String, String> = HashMap::new();
    let mut conflicted_factory_filenames: HashSet<String> = HashSet::new();
    for meta in &metas {
        for atom in &meta.written_atoms {
            let Some((_, factory_filename)) = factory_preassigned_by_atom.get(atom) else {
                continue;
            };
            if *factory_filename == meta.filename {
                continue;
            }
            match claimed_factory_filenames.get(factory_filename) {
                Some(existing) if existing != &meta.filename => {
                    conflicted_factory_filenames.insert(factory_filename.clone());
                }
                Some(_) => {}
                None => {
                    claimed_factory_filenames
                        .insert(factory_filename.clone(), meta.filename.clone());
                }
            }
        }
    }
    for filename in &conflicted_factory_filenames {
        claimed_factory_filenames.remove(filename);
    }

    // Build binding→filename map so callers can synthesize imports in factory modules.
    let mut binding_to_filename: HashMap<BindingId, String> = binding_to_module
        .iter()
        .map(|(binding, &mi)| (binding.clone(), metas[mi].filename.clone()))
        .collect();
    let mut scope_claimed_factory_bindings: HashMap<BindingId, String> = HashMap::new();
    for (binding, filename) in factory_preassigned_bindings {
        let owner_filename = claimed_factory_filenames
            .get(filename)
            .unwrap_or(filename)
            .clone();
        if &owner_filename != filename {
            scope_claimed_factory_bindings.insert(binding.clone(), owner_filename.clone());
        }
        binding_to_filename.insert(binding.clone(), owner_filename);
    }
    let factory_binding_filename_by_atom =
        atom_to_filename_binding_map(factory_importable_bindings);
    let binding_filename_by_atom = atom_to_filename_binding_map(&binding_to_filename);
    let filename_to_module: HashMap<String, usize> = metas
        .iter()
        .enumerate()
        .map(|(mi, meta)| (meta.filename.clone(), mi))
        .collect();

    // Map namespace bindings to "entry.js".  The namespace object
    // (`var ns_a = {}; __export(ns_a, {...})`) is restored into the entry
    // when the entry's own export declaration references it.  Factories
    // that use `ns_a.greet()` need to import the namespace from there.
    for boundary in &boundaries {
        if factory_referenced.contains(&boundary.ns_binding) {
            binding_to_filename
                .entry(boundary.ns_binding.clone())
                .or_insert_with(|| "entry.js".to_string());
        }
    }
    drop(imports_exports_enter);

    // Step 4 (pass 2): emit each module with synthesized imports/exports.
    let span = tracing::info_span!("esbuild: scope emit modules", count = metas.len());
    let emit_modules_enter = span.enter();
    let mut modules = Vec::new();
    let mut module_referenced_atoms: HashMap<String, HashSet<Atom>> = HashMap::new();

    for (mi, meta) in metas.iter().enumerate() {
        let mut module_items: Vec<ModuleItem> = Vec::new();

        // Synthesize imports from other scope-hoisted modules.
        let declared_atoms: HashSet<Atom> = meta
            .declared_bindings
            .iter()
            .map(|(atom, _)| atom.clone())
            .collect();
        let mut imports_by_source: HashMap<usize, Vec<BindingId>> = HashMap::new();
        let mut imports_by_filename: HashMap<String, Vec<BindingId>> = HashMap::new();
        let mut external_import_bindings: HashSet<BindingId> = HashSet::new();
        for ref_binding in &meta.referenced_bindings {
            if meta.declared_bindings.contains(ref_binding) {
                continue;
            }
            if declared_atoms.contains(&ref_binding.0) {
                continue;
            }
            if let Some(&source_mi) = binding_to_module.get(ref_binding) {
                if source_mi != mi {
                    imports_by_source
                        .entry(source_mi)
                        .or_default()
                        .push(ref_binding.clone());
                }
            } else if let Some((source_binding, source_mi)) =
                binding_module_by_atom.get(&ref_binding.0)
            {
                if *source_mi != mi {
                    imports_by_source
                        .entry(*source_mi)
                        .or_default()
                        .push(source_binding.clone());
                }
            } else if factory_preassigned_bindings.contains_key(ref_binding) {
                let source_filename = binding_to_filename
                    .get(ref_binding)
                    .expect("factory preassigned binding should have an owner filename");
                if *source_filename != meta.filename {
                    imports_by_filename
                        .entry(source_filename.clone())
                        .or_default()
                        .push(ref_binding.clone());
                }
            } else if external_imports.contains_key(ref_binding)
                && !meta.local_import_bindings.contains(ref_binding)
            {
                external_import_bindings.insert(ref_binding.clone());
            }
        }
        for atom in &meta.referenced_atoms {
            if declared_atoms.contains(atom) {
                continue;
            }
            if imports_by_source
                .values()
                .any(|bindings| bindings.iter().any(|binding| &binding.0 == atom))
            {
                continue;
            }
            // Atom fallback repairs missing specifiers on a module edge that
            // exact binding analysis already found.  Creating new edges by
            // atom alone is too broad for large bundles with reused minified
            // names and can manufacture import cycles.
            let mut added_existing_edge_import = false;
            if let Some((source_binding, source_mi)) = binding_module_by_atom.get(atom) {
                if *source_mi != mi && imports_by_source.contains_key(source_mi) {
                    imports_by_source
                        .entry(*source_mi)
                        .or_default()
                        .push(source_binding.clone());
                    added_existing_edge_import = true;
                }
            }
            if !added_existing_edge_import {
                if let Some((source_binding, source_filename)) = binding_filename_by_atom.get(atom)
                {
                    if let Some(source_mi) = filename_to_module.get(source_filename) {
                        if *source_mi != mi && imports_by_source.contains_key(source_mi) {
                            imports_by_source
                                .entry(*source_mi)
                                .or_default()
                                .push(source_binding.clone());
                            added_existing_edge_import = true;
                        }
                    }
                }
            }
            let atom_owned_by_scope_module = binding_filename_by_atom
                .get(atom)
                .is_some_and(|(_, filename)| filename_to_module.contains_key(filename));
            if !added_existing_edge_import && !atom_owned_by_scope_module {
                if let Some((source_binding, source_filename)) =
                    factory_binding_filename_by_atom.get(atom)
                {
                    add_factory_atom_import(
                        &mut imports_by_filename,
                        &meta.filename,
                        source_binding,
                        source_filename,
                    );
                }
            }
        }
        // Export getter bodies (`__export(ns, { name: () => binding })`) are
        // module surface, not body code. If a getter re-exports a binding from
        // another extracted module, import it here so the later export
        // statement does not reference an undeclared local.
        for export_binding in &meta.exported_bindings {
            if meta.declared_bindings.contains(export_binding) {
                continue;
            }
            if declared_atoms.contains(&export_binding.0) {
                continue;
            }
            if let Some(&source_mi) = binding_to_module.get(export_binding) {
                if source_mi != mi {
                    imports_by_source
                        .entry(source_mi)
                        .or_default()
                        .push(export_binding.clone());
                }
            } else if let Some((source_binding, source_mi)) =
                binding_module_by_atom.get(&export_binding.0)
            {
                if *source_mi != mi {
                    imports_by_source
                        .entry(*source_mi)
                        .or_default()
                        .push(source_binding.clone());
                }
            } else if factory_preassigned_bindings.contains_key(export_binding) {
                let source_filename = binding_to_filename
                    .get(export_binding)
                    .expect("factory preassigned binding should have an owner filename");
                if *source_filename != meta.filename {
                    imports_by_filename
                        .entry(source_filename.clone())
                        .or_default()
                        .push(export_binding.clone());
                }
            } else if external_imports.contains_key(export_binding)
                && !meta.local_import_bindings.contains(export_binding)
            {
                external_import_bindings.insert(export_binding.clone());
            }
        }
        let mut external_import_bindings: Vec<BindingId> =
            external_import_bindings.into_iter().collect();
        external_import_bindings.sort_by(|a, b| a.0.cmp(&b.0));
        let mut external_imported_atoms = HashSet::new();
        for binding in external_import_bindings {
            if declared_atoms.contains(&binding.0) {
                continue;
            }
            if let Some(import) = external_imports.get(&binding) {
                external_imported_atoms.insert(binding.0.clone());
                module_items.push(make_external_import_stmt(import));
            }
        }
        let mut import_renames: Vec<BindingRename> = Vec::new();
        let mut reserved_import_atoms = declared_atoms.clone();
        reserved_import_atoms.extend(
            binding_to_filename
                .iter()
                .filter(|(_, filename)| *filename == &meta.filename)
                .map(|((atom, _), _)| atom.clone()),
        );
        reserved_import_atoms.extend(
            meta.local_import_bindings
                .iter()
                .map(|(atom, _)| atom.clone()),
        );
        let mut import_sources: Vec<usize> = imports_by_source.keys().copied().collect();
        import_sources.sort();
        let mut imported_atoms = HashSet::new();
        for source_mi in import_sources {
            let bindings = imports_by_source.get_mut(&source_mi).unwrap();
            bindings.sort_by(|a, b| a.0.cmp(&b.0));
            bindings.dedup();
            let mut names = Vec::new();
            for binding in bindings {
                let imported = binding.0.clone();
                let local = reserve_import_atom(&imported, &mut reserved_import_atoms);
                if local != imported {
                    import_renames.push(BindingRename {
                        old: binding.clone(),
                        new: local.clone(),
                    });
                }
                imported_atoms.insert(local.clone());
                names.push((imported, local));
            }
            module_items.push(make_scope_import_stmt_with_aliases(
                &names,
                &metas[source_mi].filename,
            ));
        }
        reserved_import_atoms.extend(imported_atoms.iter().cloned());
        let mut import_filenames: Vec<String> = imports_by_filename.keys().cloned().collect();
        import_filenames.sort();
        for source_filename in import_filenames {
            let bindings = imports_by_filename.get_mut(&source_filename).unwrap();
            bindings.sort_by(|a, b| a.0.cmp(&b.0));
            bindings.dedup();
            let mut names = Vec::new();
            for binding in bindings {
                let imported = binding.0.clone();
                let local = reserve_import_atom(&imported, &mut reserved_import_atoms);
                if local != imported {
                    import_renames.push(BindingRename {
                        old: binding.clone(),
                        new: local.clone(),
                    });
                }
                imported_atoms.insert(local.clone());
                names.push((imported, local));
            }
            let rel_path = relative_import_path(&meta.filename, &source_filename);
            module_items.push(make_scope_import_stmt_with_aliases(&names, &rel_path));
        }
        imported_atoms.extend(external_imported_atoms);
        let mut local_atoms = declared_atoms.clone();
        local_atoms.extend(
            binding_to_filename
                .iter()
                .filter(|(_, filename)| *filename == &meta.filename)
                .map(|((atom, _), _)| atom.clone()),
        );
        local_atoms.extend(imported_atoms.iter().cloned());
        local_atoms.extend(
            meta.local_import_bindings
                .iter()
                .map(|(atom, _)| atom.clone()),
        );
        module_local_atoms.insert(meta.filename.clone(), local_atoms);
        module_referenced_atoms.insert(meta.filename.clone(), meta.referenced_atoms.clone());
        let namespace_atoms: HashSet<Atom> = meta
            .namespaces
            .iter()
            .map(|namespace| namespace.namespace_binding.0.clone())
            .collect();
        let exports: HashSet<Atom> = effective_exports[mi]
            .iter()
            .filter(|atom| !namespace_atoms.contains(*atom))
            .filter(|atom| declared_atoms.contains(*atom) || imported_atoms.contains(*atom))
            .cloned()
            .collect();

        // Body items with export promotion for exported bindings.
        let mut remaining_exports = exports;
        for item in scope_owned_support_decl_items(
            &meta.owned_support_bindings,
            &decl_index_by_binding,
            &original_source_items,
        ) {
            if remaining_exports.is_empty() {
                module_items.push(item);
                continue;
            }
            match try_promote_scope_export(item, &remaining_exports) {
                ScopeExportPromotion::Promoted(new_item, promoted) => {
                    module_items.push(new_item);
                    for name in &promoted {
                        remaining_exports.remove(name);
                    }
                }
                ScopeExportPromotion::Unchanged(item) => {
                    module_items.push(item);
                }
            }
        }
        let mut body_spans: Vec<Span> = Vec::with_capacity(meta.body_indices.len());
        for &i in &meta.body_indices {
            let item = source_slots[i].take().expect("body item already consumed");
            body_spans.push(item.span());
            if remaining_exports.is_empty() {
                module_items.push(item);
                continue;
            }
            match try_promote_scope_export(item, &remaining_exports) {
                ScopeExportPromotion::Promoted(new_item, promoted) => {
                    module_items.push(new_item);
                    for name in &promoted {
                        remaining_exports.remove(name);
                    }
                }
                ScopeExportPromotion::Unchanged(item) => {
                    module_items.push(item);
                }
            }
        }
        if !remaining_exports.is_empty() {
            let mut names: Vec<Atom> = remaining_exports.into_iter().collect();
            names.sort();
            module_items.push(make_scope_export_stmt(&names));
        }

        rename_bindings(&mut module_items, &import_renames);
        let mut code = emit_items(module_items, meta.filename.clone(), cm.clone());
        for namespace in &meta.namespaces {
            if !effective_exports[mi].contains(&namespace.namespace_binding.0) {
                continue;
            }
            code.push('\n');
            code.push_str(&make_namespace_export_code(
                &namespace.namespace_binding.0,
                &namespace.export_entries,
            ));
        }
        modules.push(UnpackedModule {
            id: meta.id.clone(),
            is_entry: false,
            code,
            filename: meta.filename.clone(),
            source_ranges: spans_byte_ranges(&cm, body_spans.into_iter()),
            source_input: String::new(),
            generated_source_map: Vec::new(),
        });
    }
    drop(emit_modules_enter);

    let span = tracing::info_span!("esbuild: scope build entry");
    let build_entry_enter = span.enter();
    // Track which external bindings each scope-hoisted module already imports
    // (used later to avoid duplicate imports when merging init factories).
    let mut module_already_imports: HashMap<String, HashSet<BindingId>> = HashMap::new();
    for meta in &metas {
        let imported: HashSet<BindingId> = meta
            .referenced_bindings
            .iter()
            .filter(|b| !meta.declared_bindings.contains(b))
            .filter(|b| {
                binding_to_module.contains_key(b)
                    || external_imports.contains_key(b)
                    || meta.local_import_bindings.contains(b)
            })
            .cloned()
            .collect();
        module_already_imports.insert(meta.filename.clone(), imported);
    }

    // Collect atoms that the remaining entry items already export via ESM
    // `export { ... }` declarations.  Used below to avoid synthesizing
    // duplicate exports for namespace bindings.
    // Only count unaliased exports: `export { ns_a }` makes `ns_a`
    // importable by name, but `export { ns_a as math }` does not —
    // consumers would need `import { math }`, not `import { ns_a }`.
    let entry_already_exports: HashSet<Atom> = remaining_indices
        .iter()
        .flat_map(|&i| match source_slots[i].as_ref().unwrap() {
            ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(named)) => named
                .specifiers
                .iter()
                .filter_map(|s| match s {
                    ExportSpecifier::Named(n) => {
                        let orig_atom = match &n.orig {
                            ModuleExportName::Ident(id) => &id.sym,
                            ModuleExportName::Str(_) => return None,
                        };
                        let is_direct = match &n.exported {
                            None => true,
                            Some(ModuleExportName::Ident(id)) => id.sym == *orig_atom,
                            Some(ModuleExportName::Str(_)) => false,
                        };
                        if is_direct {
                            Some(orig_atom.clone())
                        } else {
                            None
                        }
                    }
                    _ => None,
                })
                .collect::<Vec<_>>(),
            _ => vec![],
        })
        .collect();

    // Restore consumed namespace decls + __export calls whose namespace
    // binding is still referenced by the remaining entry or by factory
    // modules.  Re-inserting them keeps the namespace object alive;
    // importing the individual bindings ensures the __export getters
    // resolve correctly.
    let mut restored_items: Vec<ModuleItem> = Vec::new();
    let mut factory_ns_exports: Vec<Atom> = Vec::new();
    let mut restored_namespace_bindings: HashSet<BindingId> = HashSet::new();
    for &(ns_idx, call_idx, boundary) in &consumed_ns {
        let entry_needs = entry_referenced.contains(&boundary.ns_binding);
        let factory_needs = factory_referenced.contains(&boundary.ns_binding);
        if !entry_needs && !factory_needs {
            continue;
        }
        restored_namespace_bindings.insert(boundary.ns_binding.clone());
        restored_items.push(
            source_slots[ns_idx]
                .take()
                .expect("ns_decl already consumed"),
        );
        let _ = source_slots[call_idx]
            .take()
            .expect("export_call already consumed");
        // Restored namespaces are entry-level compatibility objects. Emitting
        // direct getters here avoids pulling the bundler's `__export` helper
        // and its late runtime aliases into the synthetic entry module.
        //
        // Extracted scope modules already use the same direct namespace setup
        // through `make_namespace_export_code`.
        restored_items.extend(make_namespace_define_property_items(
            &boundary.ns_binding.0,
            &boundary.export_entries,
        ));
        // If a factory references this namespace but the entry doesn't
        // already export it via an ESM export declaration, synthesize one
        // so the factory's `import { ns_a } from "./entry.js"` resolves.
        if factory_needs && !entry_already_exports.contains(&boundary.ns_binding.0) {
            factory_ns_exports.push(boundary.ns_binding.0.clone());
        }
    }
    for index in &removable_export_helper_indices {
        let _ = source_slots[*index].take();
    }
    if !factory_ns_exports.is_empty() {
        factory_ns_exports.sort();
        restored_items.push(make_scope_export_stmt(&factory_ns_exports));
    }
    let mut entry_imports: HashMap<usize, Vec<BindingId>> = HashMap::new();
    for ref_binding in &entry_referenced {
        if restored_namespace_bindings.contains(ref_binding) {
            continue;
        }
        if let Some(&source_mi) = binding_to_module.get(ref_binding) {
            entry_imports
                .entry(source_mi)
                .or_default()
                .push(ref_binding.clone());
        } else if let Some((source_binding, source_mi)) = binding_module_by_atom.get(&ref_binding.0)
        {
            entry_imports
                .entry(*source_mi)
                .or_default()
                .push(source_binding.clone());
        }
    }

    let mut remaining: Vec<ModuleItem> = Vec::new();
    let mut entry_tail = restored_items;
    entry_tail.extend(remaining_indices.iter().map(|&i| {
        source_slots[i]
            .take()
            .expect("remaining item already consumed")
    }));
    let mut entry_import_renames: Vec<BindingRename> = Vec::new();
    let mut entry_reserved_atoms: HashSet<Atom> = entry_tail
        .iter()
        .flat_map(|item| {
            module_item_declared_binding_ids(item)
                .into_iter()
                .chain(module_item_import_binding_ids(item))
        })
        .map(|(atom, _)| atom)
        .collect();
    if !entry_imports.is_empty() {
        let mut import_sources: Vec<usize> = entry_imports.keys().copied().collect();
        import_sources.sort();
        for source_mi in import_sources {
            let bindings = entry_imports.get_mut(&source_mi).unwrap();
            bindings.sort_by(|a, b| a.0.cmp(&b.0));
            bindings.dedup();
            let mut names = Vec::new();
            for binding in bindings {
                let imported = binding.0.clone();
                let local = reserve_import_atom(&imported, &mut entry_reserved_atoms);
                if local != imported {
                    entry_import_renames.push(BindingRename {
                        old: binding.clone(),
                        new: local.clone(),
                    });
                }
                names.push((imported, local));
            }
            remaining.push(make_scope_import_stmt_with_aliases(
                &names,
                &metas[source_mi].filename,
            ));
        }
    }
    let mut entry_factory_imports: HashMap<String, Vec<BindingId>> = HashMap::new();
    for ref_binding in &entry_referenced {
        if let Some(source_filename) = factory_preassigned_bindings.get(ref_binding) {
            let source_filename = binding_to_filename
                .get(ref_binding)
                .unwrap_or(source_filename);
            if source_filename == "entry.js" {
                continue;
            }
            entry_factory_imports
                .entry(source_filename.clone())
                .or_default()
                .push(ref_binding.clone());
        }
    }
    let mut entry_factory_filenames: Vec<String> = entry_factory_imports.keys().cloned().collect();
    entry_factory_filenames.sort();
    for source_filename in entry_factory_filenames {
        let bindings = entry_factory_imports.get_mut(&source_filename).unwrap();
        bindings.sort_by(|a, b| a.0.cmp(&b.0));
        bindings.dedup();
        let mut names = Vec::new();
        for binding in bindings {
            let imported = binding.0.clone();
            let local = reserve_import_atom(&imported, &mut entry_reserved_atoms);
            if local != imported {
                entry_import_renames.push(BindingRename {
                    old: binding.clone(),
                    new: local.clone(),
                });
            }
            names.push((imported, local));
        }
        let rel_path = relative_import_path("entry.js", &source_filename);
        remaining.push(make_scope_import_stmt_with_aliases(&names, &rel_path));
    }
    rename_bindings(&mut entry_tail, &entry_import_renames);
    remaining.extend(entry_tail);
    drop(build_entry_enter);

    (
        modules,
        remaining,
        binding_to_filename,
        module_already_imports,
        module_local_atoms,
        module_referenced_atoms,
        scope_claimed_factory_bindings,
    )
}

struct ScopeHoistedBoundary {
    ns_atom: Atom,
    ns_binding: BindingId,
    ns_decl_index: usize,
    export_call_index: usize,
    export_entries: Vec<(Atom, BindingId)>,
    exported_bindings: HashSet<BindingId>,
}

/// Detect the `__export` helper: an arrow with 2 params whose body is a
/// single for-in loop (iterating over the second param).
fn detect_export_helper(items: &[ModuleItem]) -> Option<(usize, BindingId)> {
    for (index, item) in items.iter().enumerate() {
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
            continue;
        };
        for decl in &var.decls {
            let Pat::Ident(bi) = &decl.name else { continue };
            let Some(init) = &decl.init else { continue };
            if is_export_helper(init) {
                return Some((index, (bi.id.sym.clone(), bi.id.ctxt)));
            }
        }
    }
    None
}

/// Check if an expression matches the __export pattern:
///   (target, all) => { for (var name in all) defProp(...) }
fn is_export_helper(expr: &Expr) -> bool {
    let Expr::Arrow(arrow) = expr else {
        return false;
    };
    if arrow.params.len() != 2 {
        return false;
    }
    let BlockStmtOrExpr::BlockStmt(block) = &*arrow.body else {
        return false;
    };
    if block.stmts.len() != 1 {
        return false;
    }
    matches!(&block.stmts[0], Stmt::ForIn(ForInStmt { right, .. })
        if matches!(&**right, Expr::Ident(id) if same_param_ident(&arrow.params[1], &id.sym)))
}

fn same_param_ident(pat: &Pat, sym: &Atom) -> bool {
    matches!(pat, Pat::Ident(bi) if bi.id.sym == *sym)
}

/// Find all namespace + __export call pairs.
/// Pattern: `var NS = {};` at index i, `__export(NS, { ... })` at index i+1.
fn collect_scope_hoisted_boundaries(
    items: &[ModuleItem],
    export_helper: &BindingId,
) -> Vec<ScopeHoistedBoundary> {
    let mut boundaries = Vec::new();

    for i in 0..items.len().saturating_sub(1) {
        // Check: var NS = {};
        let Some(ns_binding) = extract_empty_object_decl(&items[i]) else {
            continue;
        };

        // Check: __export(NS, { ... }) at i+1
        if !is_export_call(&items[i + 1], export_helper, &ns_binding) {
            continue;
        }

        let export_entries = extract_export_entries(&items[i + 1]);
        let exported_bindings = export_entries
            .iter()
            .map(|(_, binding)| binding.clone())
            .collect();

        boundaries.push(ScopeHoistedBoundary {
            ns_atom: ns_binding.0.clone(),
            ns_binding,
            ns_decl_index: i,
            export_call_index: i + 1,
            export_entries,
            exported_bindings,
        });
    }

    boundaries
}

/// Check if a namespace atom appears in any ESM export declaration.
/// e.g. `export { math_exports as math }` contains the ident `math_exports`.
fn namespace_is_module_exported(
    items: &[ModuleItem],
    item_infos: &[ItemBindingInfo],
    ns_binding: &BindingId,
) -> bool {
    items.iter().enumerate().any(|(i, item)| {
        matches!(item, ModuleItem::ModuleDecl(_))
            && item_infos
                .get(i)
                .is_some_and(|info| info.references.contains(ns_binding))
    })
}

/// Extract the binding atoms from `__export(NS, { key: () => binding, ... })`.
fn extract_export_entries(item: &ModuleItem) -> Vec<(Atom, BindingId)> {
    let mut entries = Vec::new();
    let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = item else {
        return entries;
    };
    let Expr::Call(call) = &**expr else {
        return entries;
    };
    if call.args.len() != 2 {
        return entries;
    }
    let Expr::Object(obj) = &*call.args[1].expr else {
        return entries;
    };
    for prop in &obj.props {
        let swc_core::ecma::ast::PropOrSpread::Prop(prop) = prop else {
            continue;
        };
        let swc_core::ecma::ast::Prop::KeyValue(kv) = &**prop else {
            continue;
        };
        let Some(export_name) = prop_name_atom(&kv.key) else {
            continue;
        };
        // Value is `() => binding` — extract the binding ident from the arrow body.
        let Expr::Arrow(arrow) = &*kv.value else {
            continue;
        };
        if let BlockStmtOrExpr::Expr(body_expr) = &*arrow.body {
            if let Expr::Ident(id) = &**body_expr {
                entries.push((export_name, (id.sym.clone(), id.ctxt)));
            }
        }
    }
    entries
}

fn prop_name_atom(name: &PropName) -> Option<Atom> {
    match name {
        PropName::Ident(id) => Some(id.sym.clone()),
        PropName::Str(s) => Some(s.value.as_str().unwrap_or("").to_string().into()),
        _ => None,
    }
}

/// Extract the binding from `var X = {};` (single declarator, empty object init).
fn extract_empty_object_decl(item: &ModuleItem) -> Option<BindingId> {
    let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) = item else {
        return None;
    };
    if var.decls.len() != 1 {
        return None;
    }
    let decl = &var.decls[0];
    let Pat::Ident(bi) = &decl.name else {
        return None;
    };
    let Some(init) = &decl.init else {
        return None;
    };
    let Expr::Object(ObjectLit { props, .. }) = &**init else {
        return None;
    };
    if !props.is_empty() {
        return None;
    }
    Some((bi.id.sym.clone(), bi.id.ctxt))
}

/// Check if an item is `__export(NS, { ... })`.
fn is_export_call(item: &ModuleItem, export_helper: &BindingId, ns_binding: &BindingId) -> bool {
    let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = item else {
        return false;
    };
    let Expr::Call(call) = &**expr else {
        return false;
    };
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };
    let Expr::Ident(callee_id) = &**callee else {
        return false;
    };
    if callee_id.sym != export_helper.0 || callee_id.ctxt != export_helper.1 || call.args.len() != 2
    {
        return false;
    }
    // First arg must be the namespace ident.
    let Expr::Ident(first_arg) = &*call.args[0].expr else {
        return false;
    };
    if first_arg.sym != ns_binding.0 || first_arg.ctxt != ns_binding.1 {
        return false;
    }
    // Second arg must be an object literal (the export map).
    matches!(&*call.args[1].expr, Expr::Object(_))
}

/// Find the end index for the last scope-hoisted module.
///
/// Three-phase scan from `from`:
///   Phase 1: find the last item that declares an exported binding.
///            Everything up to it (inclusive) is module code — this
///            captures private helpers that precede exported declarations.
///   Phase 2: reference closure — extend to include declarations of names
///            referenced by the module code (private helpers after exports).
///   Phase 3: include trailing expression statements that reference module
///            bindings (side effects). Stop at unreferenced expressions,
///            declarations, or ModuleDecls.
fn find_last_module_end(
    items: &[ModuleItem],
    item_infos: &[ItemBindingInfo],
    from: usize,
    exported_bindings: &HashSet<BindingId>,
    factory_referenced_atoms: &HashSet<Atom>,
) -> usize {
    // Phase 1: find the last item that declares an exported binding.
    let mut last_export_idx = None;
    for (i, item) in items.iter().enumerate().skip(from) {
        if is_module_boundary_item(item) {
            break;
        }
        if item_infos[i]
            .declared
            .iter()
            .any(|binding| exported_bindings.contains(binding))
        {
            last_export_idx = Some(i);
        }
    }

    let Some(last) = last_export_idx else {
        return from;
    };

    // Phase 2: reference closure — include declarations whose names are
    // referenced by the module code collected so far OR by factory modules.
    // This captures private helpers that esbuild emits after the exported
    // functions, whether they are called by other scope-hoisted code or by
    // factory modules.
    let mut end = last + 1;
    let mut module_bindings: HashSet<BindingId> = exported_bindings.clone();
    while end < items.len() {
        let item = &items[end];
        if is_module_boundary_item(item) {
            break;
        }
        let declared = &item_infos[end].declared;
        if declared.is_empty() {
            break;
        };
        let referenced_by_module = declared
            .iter()
            .any(|binding| items_reference_binding(&item_infos[from..end], binding));
        let referenced_by_factory = declared
            .iter()
            .any(|(atom, _)| factory_referenced_atoms.contains(atom));
        if !referenced_by_module && !referenced_by_factory {
            break;
        }

        for binding in declared {
            module_bindings.insert(binding.clone());
        }
        end += 1;
    }

    // Phase 3: include trailing expression statements that reference any
    // binding from this module (side effects like `register("self", ...)`
    // or `console.log(value)`). Stop at expressions that only reference
    // globals/literals, declarations, or ModuleDecls.
    for (i, item) in items.iter().enumerate().skip(end) {
        match item {
            item if is_module_boundary_item(item) => return i,
            ModuleItem::Stmt(Stmt::Expr(_)) => {
                if !item_infos[i]
                    .references
                    .iter()
                    .any(|binding| module_bindings.contains(binding))
                {
                    return i;
                }
            }
            ModuleItem::Stmt(Stmt::Decl(_)) | ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(_)) => {
                return i;
            }
            _ => return i,
        }
    }
    items.len()
}

fn is_module_boundary_item(item: &ModuleItem) -> bool {
    // `export var/function/class ...` can still belong to the current
    // scope-hoisted module; imports and re-export declarations start a
    // separate module boundary.
    matches!(item, ModuleItem::ModuleDecl(decl) if !matches!(decl, ModuleDecl::ExportDecl(_)))
}

fn items_reference_binding(item_infos: &[ItemBindingInfo], binding: &BindingId) -> bool {
    item_infos
        .iter()
        .any(|info| info.references.contains(binding))
}

fn removable_export_helper_dependency_indices(
    export_helper_index: usize,
    items: &[ModuleItem],
    item_infos: &[ItemBindingInfo],
    boundaries: &[ScopeHoistedBoundary],
) -> HashSet<usize> {
    let mut binding_to_index = HashMap::new();
    for (index, info) in item_infos.iter().enumerate() {
        for binding in &info.declared {
            binding_to_index.entry(binding.clone()).or_insert(index);
        }
    }

    let mut closure = HashSet::new();
    let mut stack = vec![export_helper_index];
    while let Some(index) = stack.pop() {
        if !closure.insert(index) {
            continue;
        }
        for reference in &item_infos[index].references {
            if let Some(&decl_index) = binding_to_index.get(reference) {
                stack.push(decl_index);
            }
        }
    }

    let mut ignored_consumers = closure.clone();
    ignored_consumers.extend(boundaries.iter().map(|boundary| boundary.export_call_index));

    closure
        .into_iter()
        .filter(|&index| {
            is_removable_export_helper_dependency_item(&items[index])
                && item_infos[index].declared.iter().all(|binding| {
                    !item_infos.iter().enumerate().any(|(consumer_index, info)| {
                        !ignored_consumers.contains(&consumer_index)
                            && info.references.contains(binding)
                    })
                })
        })
        .collect()
}

fn is_removable_export_helper_dependency_item(item: &ModuleItem) -> bool {
    match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Fn(_))) => true,
        ModuleItem::Stmt(Stmt::Decl(Decl::Var(var))) => var
            .decls
            .iter()
            .all(is_removable_export_helper_dependency_var),
        _ => false,
    }
}

fn is_removable_export_helper_dependency_var(decl: &VarDeclarator) -> bool {
    let Some(init) = decl.init.as_deref() else {
        return true;
    };

    matches!(init, Expr::Fn(_) | Expr::Arrow(_))
        || is_object_destructure_from_object(&decl.name, init)
        || is_object_member_alias(init)
}

fn is_scope_support_declaration_for_binding(item: &ModuleItem, binding: &BindingId) -> bool {
    match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => {
            fn_decl.ident.sym == binding.0 && fn_decl.ident.ctxt == binding.1
        }
        ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => var_decl.decls.iter().any(|decl| {
            pat_declared_binding_ids(&decl.name)
                .iter()
                .any(|decl_binding| decl_binding == binding)
                && decl
                    .init
                    .as_deref()
                    .is_some_and(|init| matches!(init, Expr::Fn(_) | Expr::Arrow(_)))
        }),
        _ => false,
    }
}

fn is_object_destructure_from_object(name: &Pat, init: &Expr) -> bool {
    matches!(name, Pat::Object(_)) && matches!(init, Expr::Ident(ident) if ident.sym == *"Object")
}

fn is_object_member_alias(init: &Expr) -> bool {
    let Expr::Member(member) = init else {
        return false;
    };
    matches!(member.obj.as_ref(), Expr::Ident(ident) if ident.sym == *"Object")
        && matches!(&member.prop, MemberProp::Ident(_))
}

#[derive(Default)]
struct ItemBindingInfo {
    declared: HashSet<BindingId>,
    references: HashSet<BindingId>,
}

fn build_item_binding_infos(items: &[ModuleItem]) -> Vec<ItemBindingInfo> {
    // Collect per-item declared bindings in one pass, then build the
    // union for reference filtering.  This avoids calling
    // module_item_declared_binding_ids twice per item.
    let per_item_declared: Vec<HashSet<BindingId>> = items
        .iter()
        .map(|item| module_item_declared_binding_ids(item).into_iter().collect())
        .collect();

    let top_level_bindings: HashSet<BindingId> = per_item_declared
        .iter()
        .flat_map(|s| s.iter().cloned())
        .chain(
            items
                .iter()
                .flat_map(|item| module_item_import_binding_ids(item).into_iter()),
        )
        .collect();

    items
        .iter()
        .zip(per_item_declared)
        .map(|(item, declared)| {
            let mut collector = TopLevelRefCollector {
                top_level_bindings: &top_level_bindings,
                references: HashSet::new(),
            };
            item.visit_with(&mut collector);
            ItemBindingInfo {
                declared,
                references: collector.references,
            }
        })
        .collect()
}

fn item_binding_info_for(
    item: &ModuleItem,
    top_level_bindings: &HashSet<BindingId>,
) -> ItemBindingInfo {
    let declared: HashSet<BindingId> = module_item_declared_binding_ids(item).into_iter().collect();
    let mut collector = TopLevelRefCollector {
        top_level_bindings,
        references: HashSet::new(),
    };
    item.visit_with(&mut collector);
    ItemBindingInfo {
        declared,
        references: collector.references,
    }
}

fn module_item_import_binding_ids(item: &ModuleItem) -> Vec<BindingId> {
    let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item else {
        return vec![];
    };
    import
        .specifiers
        .iter()
        .map(|specifier| match specifier {
            ImportSpecifier::Named(named) => (named.local.sym.clone(), named.local.ctxt),
            ImportSpecifier::Default(default) => (default.local.sym.clone(), default.local.ctxt),
            ImportSpecifier::Namespace(namespace) => {
                (namespace.local.sym.clone(), namespace.local.ctxt)
            }
        })
        .collect()
}

fn filter_item_excluding_bindings(
    item: &ModuleItem,
    excluded: &HashSet<BindingId>,
    excluded_atoms: &HashSet<Atom>,
) -> Option<ModuleItem> {
    match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => {
            let mut filtered = var_decl.clone();
            filtered.decls.retain(|decl| {
                let ids = pat_declared_binding_ids(&decl.name);
                ids.is_empty()
                    || !ids
                        .iter()
                        .all(|id| excluded.contains(id) || excluded_atoms.contains(&id.0))
            });
            if filtered.decls.is_empty() {
                None
            } else {
                Some(ModuleItem::Stmt(Stmt::Decl(Decl::Var(filtered))))
            }
        }
        _ => {
            let declared = module_item_declared_binding_ids(item);
            if !declared.is_empty()
                && declared
                    .iter()
                    .all(|id| excluded.contains(id) || excluded_atoms.contains(&id.0))
            {
                None
            } else {
                Some(item.clone())
            }
        }
    }
}

#[derive(Clone)]
struct ExternalImport {
    decl: ImportDecl,
    specifier: ImportSpecifier,
}

fn collect_external_imports(
    analysis_items: &[ModuleItem],
    source_items: &[ModuleItem],
) -> HashMap<BindingId, ExternalImport> {
    let mut imports = HashMap::new();
    for (analysis_item, source_item) in analysis_items.iter().zip(source_items) {
        let ModuleItem::ModuleDecl(ModuleDecl::Import(analysis_import)) = analysis_item else {
            continue;
        };
        let ModuleItem::ModuleDecl(ModuleDecl::Import(source_import)) = source_item else {
            continue;
        };
        for (analysis_specifier, source_specifier) in analysis_import
            .specifiers
            .iter()
            .zip(source_import.specifiers.iter())
        {
            let binding = import_specifier_binding(analysis_specifier);
            imports.entry(binding).or_insert_with(|| ExternalImport {
                decl: source_import.clone(),
                specifier: source_specifier.clone(),
            });
        }
    }
    imports
}

fn import_specifier_binding(specifier: &ImportSpecifier) -> BindingId {
    match specifier {
        ImportSpecifier::Named(named) => (named.local.sym.clone(), named.local.ctxt),
        ImportSpecifier::Default(default) => (default.local.sym.clone(), default.local.ctxt),
        ImportSpecifier::Namespace(namespace) => {
            (namespace.local.sym.clone(), namespace.local.ctxt)
        }
    }
}

struct TopLevelRefCollector<'a> {
    top_level_bindings: &'a HashSet<BindingId>,
    references: HashSet<BindingId>,
}

struct AtomRefCollector<'a> {
    candidate_atoms: &'a HashSet<Atom>,
    references: HashSet<Atom>,
    shadowed_atoms: Vec<HashSet<Atom>>,
}

impl Visit for AtomRefCollector<'_> {
    fn visit_binding_ident(&mut self, ident: &BindingIdent) {
        if let Some(scope) = self.shadowed_atoms.last_mut() {
            scope.insert(ident.id.sym.clone());
        }
    }

    fn visit_function(&mut self, function: &Function) {
        self.shadowed_atoms.push(HashSet::new());
        function.visit_children_with(self);
        self.shadowed_atoms.pop();
    }

    fn visit_arrow_expr(&mut self, expr: &ArrowExpr) {
        self.shadowed_atoms.push(HashSet::new());
        expr.visit_children_with(self);
        self.shadowed_atoms.pop();
    }

    fn visit_ident(&mut self, ident: &swc_core::ecma::ast::Ident) {
        if self.candidate_atoms.contains(&ident.sym)
            && !self
                .shadowed_atoms
                .iter()
                .any(|scope| scope.contains(&ident.sym))
        {
            self.references.insert(ident.sym.clone());
        }
    }

    fn visit_member_expr(&mut self, expr: &swc_core::ecma::ast::MemberExpr) {
        expr.obj.visit_with(self);
        if let swc_core::ecma::ast::MemberProp::Computed(c) = &expr.prop {
            c.visit_with(self);
        }
    }

    fn visit_member_prop(&mut self, prop: &swc_core::ecma::ast::MemberProp) {
        if let swc_core::ecma::ast::MemberProp::Computed(c) = prop {
            c.visit_with(self);
        }
    }

    fn visit_prop_name(&mut self, prop: &PropName) {
        if let PropName::Computed(c) = prop {
            c.visit_with(self);
        }
    }
}

impl TopLevelRefCollector<'_> {
    fn visit_binding_pat_defaults(&mut self, pat: &Pat) {
        match pat {
            Pat::Array(array) => {
                for elem in array.elems.iter().flatten() {
                    self.visit_binding_pat_defaults(elem);
                }
            }
            Pat::Object(object) => {
                for prop in &object.props {
                    match prop {
                        swc_core::ecma::ast::ObjectPatProp::KeyValue(kv) => {
                            self.visit_binding_pat_defaults(&kv.value);
                        }
                        swc_core::ecma::ast::ObjectPatProp::Assign(assign) => {
                            if let Some(value) = &assign.value {
                                value.visit_with(self);
                            }
                        }
                        swc_core::ecma::ast::ObjectPatProp::Rest(rest) => {
                            self.visit_binding_pat_defaults(&rest.arg);
                        }
                    }
                }
            }
            Pat::Assign(assign) => {
                assign.right.visit_with(self);
                self.visit_binding_pat_defaults(&assign.left);
            }
            Pat::Rest(rest) => self.visit_binding_pat_defaults(&rest.arg),
            _ => {}
        }
    }
}

impl Visit for TopLevelRefCollector<'_> {
    fn visit_binding_ident(&mut self, _: &BindingIdent) {}

    fn visit_pat(&mut self, pat: &Pat) {
        self.visit_binding_pat_defaults(pat);
    }

    fn visit_var_declarator(&mut self, declarator: &VarDeclarator) {
        self.visit_binding_pat_defaults(&declarator.name);
        if let Some(init) = &declarator.init {
            init.visit_with(self);
        }
    }

    fn visit_fn_decl(&mut self, decl: &FnDecl) {
        decl.function.visit_with(self);
    }

    fn visit_class_decl(&mut self, decl: &ClassDecl) {
        decl.class.visit_with(self);
    }

    fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
        if let Some(ident) = assign.left.as_ident() {
            let binding = (ident.sym.clone(), ident.ctxt);
            if self.top_level_bindings.contains(&binding) {
                self.references.insert(binding);
            }
        }
        assign.left.visit_with(self);
        assign.right.visit_with(self);
    }

    fn visit_update_expr(&mut self, update: &swc_core::ecma::ast::UpdateExpr) {
        if let Expr::Ident(ident) = &*update.arg {
            let binding = (ident.sym.clone(), ident.ctxt);
            if self.top_level_bindings.contains(&binding) {
                self.references.insert(binding);
            }
        }
    }

    fn visit_ident(&mut self, ident: &swc_core::ecma::ast::Ident) {
        let binding = (ident.sym.clone(), ident.ctxt);
        if self.top_level_bindings.contains(&binding) {
            self.references.insert(binding);
        }
    }

    fn visit_member_expr(&mut self, expr: &swc_core::ecma::ast::MemberExpr) {
        expr.obj.visit_with(self);
        if let swc_core::ecma::ast::MemberProp::Computed(c) = &expr.prop {
            c.visit_with(self);
        }
    }

    fn visit_member_prop(&mut self, prop: &swc_core::ecma::ast::MemberProp) {
        if let swc_core::ecma::ast::MemberProp::Computed(c) = prop {
            c.visit_with(self);
        }
    }

    fn visit_prop_name(&mut self, name: &PropName) {
        if let PropName::Computed(c) = name {
            c.visit_with(self);
        }
    }

    fn visit_super_prop(&mut self, prop: &swc_core::ecma::ast::SuperProp) {
        if let swc_core::ecma::ast::SuperProp::Computed(c) = prop {
            c.visit_with(self);
        }
    }
}

/// Collect top-level bindings that appear as assignment targets in a statement.
/// This detects `X = expr` and `X = expr, Y = expr` patterns where X/Y are
/// top-level bindings (not local declarations).
fn collect_write_bindings(
    stmt: &Stmt,
    top_level_bindings: &HashSet<BindingId>,
    out: &mut HashSet<BindingId>,
) {
    struct WriteCollector<'a> {
        top_level_bindings: &'a HashSet<BindingId>,
        writes: &'a mut HashSet<BindingId>,
    }

    impl Visit for WriteCollector<'_> {
        fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
            if let Some(ident) = assign.left.as_ident() {
                let binding = (ident.sym.clone(), ident.ctxt);
                if self.top_level_bindings.contains(&binding) {
                    self.writes.insert(binding);
                }
            } else if let swc_core::ecma::ast::AssignTarget::Pat(pat) = &assign.left {
                let mut collector = AssignTargetWriteCollector {
                    top_level_bindings: self.top_level_bindings,
                    writes: self.writes,
                };
                pat.visit_with(&mut collector);
            }
            assign.right.visit_with(self);
        }

        fn visit_update_expr(&mut self, update: &swc_core::ecma::ast::UpdateExpr) {
            if let Expr::Ident(ident) = &*update.arg {
                let binding = (ident.sym.clone(), ident.ctxt);
                if self.top_level_bindings.contains(&binding) {
                    self.writes.insert(binding);
                }
            }
        }
    }

    struct AssignTargetWriteCollector<'a> {
        top_level_bindings: &'a HashSet<BindingId>,
        writes: &'a mut HashSet<BindingId>,
    }

    impl Visit for AssignTargetWriteCollector<'_> {
        fn visit_ident(&mut self, ident: &Ident) {
            let binding = (ident.sym.clone(), ident.ctxt);
            if self.top_level_bindings.contains(&binding) {
                self.writes.insert(binding);
            }
        }
    }

    let mut collector = WriteCollector {
        top_level_bindings,
        writes: out,
    };
    stmt.visit_with(&mut collector);
}

fn scope_write_atoms_for_item(
    item: &ModuleItem,
    top_level_bindings: &HashSet<BindingId>,
    top_level_atoms: &HashSet<Atom>,
) -> HashSet<Atom> {
    let mut local_collector = NonTopLevelBindingCollector {
        top_level_bindings,
        local_bindings: HashSet::new(),
    };
    item.visit_with(&mut local_collector);

    let mut write_collector = ScopeWriteAtomCollector {
        top_level_bindings,
        top_level_atoms,
        local_bindings: &local_collector.local_bindings,
        writes: HashSet::new(),
    };
    item.visit_with(&mut write_collector);
    write_collector.writes
}

struct NonTopLevelBindingCollector<'a> {
    top_level_bindings: &'a HashSet<BindingId>,
    local_bindings: HashSet<BindingId>,
}

impl Visit for NonTopLevelBindingCollector<'_> {
    fn visit_binding_ident(&mut self, ident: &BindingIdent) {
        let binding = (ident.id.sym.clone(), ident.id.ctxt);
        if !self.top_level_bindings.contains(&binding) {
            self.local_bindings.insert(binding);
        }
    }
}

struct ScopeWriteAtomCollector<'a> {
    top_level_bindings: &'a HashSet<BindingId>,
    top_level_atoms: &'a HashSet<Atom>,
    local_bindings: &'a HashSet<BindingId>,
    writes: HashSet<Atom>,
}

impl ScopeWriteAtomCollector<'_> {
    fn record_ident(&mut self, ident: &Ident) {
        let binding = (ident.sym.clone(), ident.ctxt);
        if self.top_level_bindings.contains(&binding)
            || (self.top_level_atoms.contains(&ident.sym)
                && !self.local_bindings.contains(&binding))
        {
            self.writes.insert(ident.sym.clone());
        }
    }
}

impl Visit for ScopeWriteAtomCollector<'_> {
    fn visit_assign_expr(&mut self, assign: &swc_core::ecma::ast::AssignExpr) {
        collect_scope_write_target(&assign.left, self);
        assign.right.visit_with(self);
    }

    fn visit_update_expr(&mut self, update: &swc_core::ecma::ast::UpdateExpr) {
        if let Expr::Ident(ident) = update.arg.as_ref() {
            self.record_ident(ident);
        }
    }
}

fn collect_scope_write_target(target: &AssignTarget, collector: &mut ScopeWriteAtomCollector<'_>) {
    match target {
        AssignTarget::Simple(SimpleAssignTarget::Ident(ident)) => {
            collector.record_ident(&ident.id);
        }
        AssignTarget::Simple(simple) => {
            simple.visit_with(collector);
        }
        AssignTarget::Pat(pat) => collect_scope_write_pat_target(pat, collector),
    }
}

fn collect_scope_write_pat_target(
    target: &AssignTargetPat,
    collector: &mut ScopeWriteAtomCollector<'_>,
) {
    match target {
        AssignTargetPat::Array(array) => {
            for elem in array.elems.iter().flatten() {
                collect_scope_write_pat(elem, collector);
            }
        }
        AssignTargetPat::Object(object) => {
            for prop in &object.props {
                match prop {
                    ObjectPatProp::KeyValue(kv) => collect_scope_write_pat(&kv.value, collector),
                    ObjectPatProp::Assign(assign) => collector.record_ident(&assign.key),
                    ObjectPatProp::Rest(rest) => collect_scope_write_pat(&rest.arg, collector),
                }
            }
        }
        AssignTargetPat::Invalid(_) => {}
    }
}

fn collect_scope_write_pat(pat: &Pat, collector: &mut ScopeWriteAtomCollector<'_>) {
    match pat {
        Pat::Ident(ident) => collector.record_ident(&ident.id),
        Pat::Array(array) => {
            for elem in array.elems.iter().flatten() {
                collect_scope_write_pat(elem, collector);
            }
        }
        Pat::Object(object) => {
            for prop in &object.props {
                match prop {
                    ObjectPatProp::Assign(assign) => collector.record_ident(&assign.key),
                    ObjectPatProp::KeyValue(kv) => collect_scope_write_pat(&kv.value, collector),
                    ObjectPatProp::Rest(rest) => collect_scope_write_pat(&rest.arg, collector),
                }
            }
        }
        Pat::Rest(rest) => collect_scope_write_pat(&rest.arg, collector),
        Pat::Assign(assign) => {
            collect_scope_write_pat(&assign.left, collector);
            assign.right.visit_with(collector);
        }
        Pat::Expr(expr) => expr.visit_with(collector),
        Pat::Invalid(_) => {}
    }
}

// ---------------------------------------------------------------------------
// Import / export synthesis for scope-hoisted modules
// ---------------------------------------------------------------------------

/// Compute a relative import specifier from `importer` to `target`.
/// Both are flat output filenames (e.g. `src/consumer.js`, `ns_a.js`).
/// Returns a string suitable for an ES import source (e.g. `./ns_a.js`,
/// `../ns_a.js`).
fn relative_import_path(importer: &str, target: &str) -> String {
    relative_import_specifier(importer, target)
}

fn reserve_import_atom(imported: &Atom, reserved: &mut HashSet<Atom>) -> Atom {
    if reserved.insert(imported.clone()) {
        return imported.clone();
    }

    for suffix in 2.. {
        let candidate: Atom = format!("{imported}${suffix}").into();
        if reserved.insert(candidate.clone()) {
            return candidate;
        }
    }

    unreachable!("open-ended suffix search must find an unused import atom")
}

fn make_scope_import_stmt(names: &[Atom], from: &str) -> ModuleItem {
    let names: Vec<(Atom, Atom)> = names
        .iter()
        .map(|name| (name.clone(), name.clone()))
        .collect();
    make_scope_import_stmt_with_aliases(&names, from)
}

fn make_scope_import_stmt_with_aliases(names: &[(Atom, Atom)], from: &str) -> ModuleItem {
    let specifiers = names
        .iter()
        .map(|(imported, local)| {
            ImportSpecifier::Named(ImportNamedSpecifier {
                span: Default::default(),
                local: Ident::new(local.clone(), Default::default(), Default::default()),
                imported: if imported == local {
                    None
                } else {
                    Some(ModuleExportName::Ident(Ident::new(
                        imported.clone(),
                        Default::default(),
                        Default::default(),
                    )))
                },
                is_type_only: false,
            })
        })
        .collect();
    ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
        span: Default::default(),
        specifiers,
        src: Box::new(Str {
            span: Default::default(),
            value: if from.starts_with('.') || from.starts_with('/') {
                from.into()
            } else {
                format!("./{from}").into()
            },
            raw: None,
        }),
        type_only: false,
        with: None,
        phase: Default::default(),
    }))
}

fn make_external_import_stmt(import: &ExternalImport) -> ModuleItem {
    let mut decl = import.decl.clone();
    decl.specifiers = vec![import.specifier.clone()];
    ModuleItem::ModuleDecl(ModuleDecl::Import(decl))
}

fn make_scope_export_stmt(names: &[Atom]) -> ModuleItem {
    let specifiers = names
        .iter()
        .map(|name| {
            ExportSpecifier::Named(ExportNamedSpecifier {
                span: Default::default(),
                orig: ModuleExportName::Ident(Ident::new(
                    name.clone(),
                    Default::default(),
                    Default::default(),
                )),
                exported: None,
                is_type_only: false,
            })
        })
        .collect();
    ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(NamedExport {
        span: Default::default(),
        specifiers,
        src: None,
        type_only: false,
        with: None,
    }))
}

fn make_namespace_define_property_items(
    namespace: &Atom,
    entries: &[(Atom, BindingId)],
) -> Vec<ModuleItem> {
    let mut items = Vec::new();
    let mut seen = HashSet::new();
    for (export_name, (binding_name, _)) in entries {
        if !seen.insert(export_name.clone()) {
            continue;
        }
        items.push(ModuleItem::Stmt(Stmt::Expr(ExprStmt {
            span: DUMMY_SP,
            expr: Box::new(Expr::Call(CallExpr {
                span: DUMMY_SP,
                ctxt: SyntaxContext::empty(),
                callee: Callee::Expr(Box::new(Expr::Member(MemberExpr {
                    span: DUMMY_SP,
                    obj: Box::new(Expr::Ident(Ident::new(
                        "Object".into(),
                        DUMMY_SP,
                        SyntaxContext::empty(),
                    ))),
                    prop: MemberProp::Ident(IdentName::new("defineProperty".into(), DUMMY_SP)),
                }))),
                args: vec![
                    ExprOrSpread {
                        spread: None,
                        expr: Box::new(Expr::Ident(Ident::new(
                            namespace.clone(),
                            DUMMY_SP,
                            SyntaxContext::empty(),
                        ))),
                    },
                    ExprOrSpread {
                        spread: None,
                        expr: Box::new(Expr::Lit(Lit::Str(Str {
                            span: DUMMY_SP,
                            value: export_name.clone().into(),
                            raw: None,
                        }))),
                    },
                    ExprOrSpread {
                        spread: None,
                        expr: Box::new(Expr::Object(ObjectLit {
                            span: DUMMY_SP,
                            props: vec![
                                PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
                                    key: PropName::Ident(IdentName::new(
                                        "enumerable".into(),
                                        DUMMY_SP,
                                    )),
                                    value: Box::new(Expr::Lit(Lit::Bool(Bool {
                                        span: DUMMY_SP,
                                        value: true,
                                    }))),
                                }))),
                                PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
                                    key: PropName::Ident(IdentName::new("get".into(), DUMMY_SP)),
                                    value: Box::new(Expr::Arrow(ArrowExpr {
                                        span: DUMMY_SP,
                                        ctxt: SyntaxContext::empty(),
                                        params: Vec::new(),
                                        body: Box::new(BlockStmtOrExpr::Expr(Box::new(
                                            Expr::Ident(Ident::new(
                                                binding_name.clone(),
                                                DUMMY_SP,
                                                SyntaxContext::empty(),
                                            )),
                                        ))),
                                        is_async: false,
                                        is_generator: false,
                                        type_params: None,
                                        return_type: None,
                                    })),
                                }))),
                            ],
                        })),
                    },
                ],
                type_args: None,
            })),
        })));
    }
    items
}

fn make_namespace_export_code(namespace: &Atom, entries: &[(Atom, BindingId)]) -> String {
    let mut code = format!("export var {namespace} = {{}};\n");
    let mut seen = HashSet::new();
    for (export_name, (binding_name, _)) in entries {
        if !seen.insert(export_name.clone()) {
            continue;
        }
        code.push_str(&format!(
            "Object.defineProperty({namespace}, {}, {{ enumerable: true, get: () => {binding_name} }});\n",
            js_string_literal(export_name)
        ));
    }
    code
}

fn js_string_literal(value: &Atom) -> String {
    let mut out = String::from("\"");
    for ch in value.chars() {
        match ch {
            '\\' => out.push_str("\\\\"),
            '"' => out.push_str("\\\""),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            _ => out.push(ch),
        }
    }
    out.push('"');
    out
}

fn factory_owned_decl_items(
    filename: &str,
    factory_owned_bindings: &HashMap<String, HashSet<BindingId>>,
    top_level_decl_items: &HashMap<BindingId, (usize, ModuleItem, ModuleItem)>,
) -> Vec<ModuleItem> {
    factory_owned_decl_items_from(filename, factory_owned_bindings, top_level_decl_items, true)
}

fn scope_owned_support_decl_items(
    owned: &HashSet<BindingId>,
    decl_index_by_binding: &HashMap<BindingId, usize>,
    source_items: &[ModuleItem],
) -> Vec<ModuleItem> {
    if owned.is_empty() {
        return vec![];
    }
    let owned_atoms: HashSet<Atom> = owned.iter().map(|(atom, _)| atom.clone()).collect();
    let mut item_indices: Vec<(usize, ModuleItem)> = owned
        .iter()
        .filter_map(|binding| {
            decl_index_by_binding
                .get(binding)
                .map(|index| (*index, source_items[*index].clone()))
        })
        .collect();
    item_indices.sort_by_key(|(index, _)| *index);
    item_indices.dedup_by_key(|(index, _)| *index);
    item_indices
        .into_iter()
        .filter_map(|(_, item)| filter_item_to_owned_bindings(&item, &owned_atoms))
        .collect()
}

fn factory_owned_analysis_decl_items(
    filename: &str,
    factory_owned_bindings: &HashMap<String, HashSet<BindingId>>,
    top_level_decl_items: &HashMap<BindingId, (usize, ModuleItem, ModuleItem)>,
) -> Vec<ModuleItem> {
    factory_owned_decl_items_from(
        filename,
        factory_owned_bindings,
        top_level_decl_items,
        false,
    )
}

fn factory_owned_decl_items_from(
    filename: &str,
    factory_owned_bindings: &HashMap<String, HashSet<BindingId>>,
    top_level_decl_items: &HashMap<BindingId, (usize, ModuleItem, ModuleItem)>,
    use_source: bool,
) -> Vec<ModuleItem> {
    let Some(owned) = factory_owned_bindings.get(filename) else {
        return vec![];
    };
    let owned_atoms: HashSet<Atom> = owned.iter().map(|(atom, _)| atom.clone()).collect();
    let mut item_indices: Vec<(usize, ModuleItem)> = owned
        .iter()
        .filter_map(|binding| {
            top_level_decl_items
                .get(binding)
                .map(|(index, source, analysis)| {
                    if use_source {
                        (*index, source.clone())
                    } else {
                        (*index, analysis.clone())
                    }
                })
        })
        .collect();
    item_indices.sort_by_key(|(index, _)| *index);
    item_indices.dedup_by_key(|(index, _)| *index);
    item_indices
        .into_iter()
        .filter_map(|(_, item)| filter_item_to_owned_bindings(&item, &owned_atoms))
        .collect()
}

fn factory_owned_export_items(
    filename: &str,
    factory_owned_bindings: &HashMap<String, HashSet<BindingId>>,
) -> Vec<ModuleItem> {
    let Some(owned) = factory_owned_bindings.get(filename) else {
        return vec![];
    };
    let mut names: Vec<Atom> = owned.iter().map(|(atom, _)| atom.clone()).collect();
    names.sort();
    names.dedup();
    if names.is_empty() {
        vec![]
    } else {
        vec![make_scope_export_stmt(&names)]
    }
}

fn filter_item_to_owned_bindings(
    item: &ModuleItem,
    owned_atoms: &HashSet<Atom>,
) -> Option<ModuleItem> {
    match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl)))
            if owned_atoms.contains(&fn_decl.ident.sym) =>
        {
            Some(item.clone())
        }
        ModuleItem::Stmt(Stmt::Decl(Decl::Class(class_decl)))
            if owned_atoms.contains(&class_decl.ident.sym) =>
        {
            Some(item.clone())
        }
        ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => {
            let stmt_bindings: HashSet<BindingId> = var_decl
                .decls
                .iter()
                .flat_map(|decl| pat_declared_binding_ids(&decl.name))
                .collect();
            let mut keep_atoms: HashSet<Atom> = HashSet::new();
            for decl in &var_decl.decls {
                let decl_atoms: Vec<Atom> = pat_declared_binding_ids(&decl.name)
                    .into_iter()
                    .map(|(atom, _)| atom)
                    .collect();
                if !decl_atoms.iter().any(|atom| owned_atoms.contains(atom)) {
                    continue;
                }
                keep_atoms.extend(decl_atoms);
                let mut collector = TopLevelRefCollector {
                    top_level_bindings: &stmt_bindings,
                    references: HashSet::new(),
                };
                decl.visit_with(&mut collector);
                keep_atoms.extend(collector.references.into_iter().map(|(atom, _)| atom));
            }

            if var_decl
                .decls
                .iter()
                .any(|decl| pat_declares_owned(&decl.name, &keep_atoms))
            {
                let mut filtered = var_decl.clone();
                filtered
                    .decls
                    .retain(|decl| pat_declares_owned(&decl.name, &keep_atoms));
                Some(ModuleItem::Stmt(Stmt::Decl(Decl::Var(filtered))))
            } else {
                None
            }
        }
        _ => None,
    }
}

fn pat_declared_binding_ids(pat: &Pat) -> Vec<BindingId> {
    find_pat_ids(pat)
}

fn pat_declares_owned(pat: &Pat, owned_atoms: &HashSet<Atom>) -> bool {
    match pat {
        Pat::Ident(bi) => owned_atoms.contains(&bi.id.sym),
        Pat::Array(array) => array
            .elems
            .iter()
            .flatten()
            .any(|elem| pat_declares_owned(elem, owned_atoms)),
        Pat::Object(object) => object.props.iter().any(|prop| match prop {
            swc_core::ecma::ast::ObjectPatProp::KeyValue(kv) => {
                pat_declares_owned(&kv.value, owned_atoms)
            }
            swc_core::ecma::ast::ObjectPatProp::Assign(assign) => {
                owned_atoms.contains(&assign.key.sym)
            }
            swc_core::ecma::ast::ObjectPatProp::Rest(rest) => {
                pat_declares_owned(&rest.arg, owned_atoms)
            }
        }),
        Pat::Assign(assign) => pat_declares_owned(&assign.left, owned_atoms),
        Pat::Rest(rest) => pat_declares_owned(&rest.arg, owned_atoms),
        _ => false,
    }
}

enum ScopeExportPromotion {
    Promoted(ModuleItem, Vec<Atom>),
    Unchanged(ModuleItem),
}

fn try_promote_scope_export(item: ModuleItem, exported: &HashSet<Atom>) -> ScopeExportPromotion {
    match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Fn(ref fn_decl)))
            if exported.contains(&fn_decl.ident.sym) =>
        {
            let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) = item else {
                unreachable!()
            };
            let names = vec![fn_decl.ident.sym.clone()];
            ScopeExportPromotion::Promoted(
                ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                    span: Default::default(),
                    decl: Decl::Fn(fn_decl),
                })),
                names,
            )
        }
        ModuleItem::Stmt(Stmt::Decl(Decl::Class(ref class_decl)))
            if exported.contains(&class_decl.ident.sym) =>
        {
            let ModuleItem::Stmt(Stmt::Decl(Decl::Class(class_decl))) = item else {
                unreachable!()
            };
            let names = vec![class_decl.ident.sym.clone()];
            ScopeExportPromotion::Promoted(
                ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                    span: Default::default(),
                    decl: Decl::Class(class_decl),
                })),
                names,
            )
        }
        ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => {
            if var_decl.decls.len() == 1 {
                let decl = &var_decl.decls[0];
                if let Pat::Ident(bi) = &decl.name {
                    if exported.contains(&bi.id.sym)
                        && decl.init.as_deref().is_some_and(is_noop_arrow_expr)
                    {
                        let names = vec![bi.id.sym.clone()];
                        return ScopeExportPromotion::Promoted(
                            make_noop_export_function(&bi.id.sym),
                            names,
                        );
                    }
                }
            }
            let all_exported = var_decl
                .decls
                .iter()
                .all(|d| matches!(&d.name, Pat::Ident(bi) if exported.contains(&bi.id.sym)));
            if !all_exported {
                return ScopeExportPromotion::Unchanged(ModuleItem::Stmt(Stmt::Decl(Decl::Var(
                    var_decl,
                ))));
            }
            let names: Vec<Atom> = var_decl
                .decls
                .iter()
                .filter_map(|d| {
                    if let Pat::Ident(bi) = &d.name {
                        Some(bi.id.sym.clone())
                    } else {
                        Option::None
                    }
                })
                .collect();
            if names.is_empty() {
                return ScopeExportPromotion::Unchanged(ModuleItem::Stmt(Stmt::Decl(Decl::Var(
                    var_decl,
                ))));
            }
            ScopeExportPromotion::Promoted(
                ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                    span: Default::default(),
                    decl: Decl::Var(var_decl),
                })),
                names,
            )
        }
        item => ScopeExportPromotion::Unchanged(item),
    }
}

fn is_noop_arrow_expr(expr: &Expr) -> bool {
    let Expr::Arrow(ArrowExpr { params, body, .. }) = expr else {
        return false;
    };
    params.is_empty()
        && matches!(
            &**body,
            BlockStmtOrExpr::BlockStmt(block) if block.stmts.is_empty()
        )
}

fn make_noop_export_function(name: &Atom) -> ModuleItem {
    ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
        span: Default::default(),
        decl: Decl::Fn(FnDecl {
            ident: Ident::new(name.clone(), Default::default(), Default::default()),
            declare: false,
            function: Box::new(Function {
                params: vec![],
                decorators: vec![],
                span: Default::default(),
                ctxt: Default::default(),
                body: Some(BlockStmt {
                    span: Default::default(),
                    ctxt: Default::default(),
                    stmts: vec![],
                }),
                is_generator: false,
                is_async: false,
                type_params: None,
                return_type: None,
            }),
        }),
    }))
}

/// Case-insensitive filename dedup matching the CLI's `deduplicate_path` logic.
/// Probes `filename`, then `{stem}_2.{ext}`, `{stem}_3.{ext}`, ... until a
/// name not in `seen` is found.  Inserts the winner and returns it.
fn dedup_filename(filename: &str, seen: &mut HashSet<String>) -> String {
    if seen.insert(filename.to_ascii_lowercase()) {
        return filename.to_string();
    }
    let (stem, ext) = match filename.rfind('.') {
        Some(i) => (&filename[..i], &filename[i + 1..]),
        None => (filename, "js"),
    };
    let mut n = 2u32;
    loop {
        let candidate = format!("{stem}_{n}.{ext}");
        if seen.insert(candidate.to_ascii_lowercase()) {
            return candidate;
        }
        n += 1;
    }
}

fn emit_items(items: Vec<ModuleItem>, filename: String, cm: Lrc<SourceMap>) -> String {
    let span = tracing::info_span!("esbuild: emit_items", count = items.len());
    let _enter = span.enter();
    let module = Module {
        span: Default::default(),
        body: items,
        shebang: None,
    };
    emit_module(module, filename, cm)
}

// ---------------------------------------------------------------------------
// Code generation
// ---------------------------------------------------------------------------

fn emit_module(module: Module, filename: String, cm: Lrc<SourceMap>) -> String {
    let _fm = cm.new_source_file(FileName::Custom(filename).into(), String::new());
    emit_module_raw(&module, cm).unwrap_or_default()
}

fn emit_module_raw(module: &Module, cm: Lrc<SourceMap>) -> anyhow::Result<String> {
    let mut output = Vec::new();
    {
        let mut emitter = Emitter {
            cfg: Config::default().with_minify(false),
            cm: cm.clone(),
            comments: None,
            wr: JsWriter::new(cm.clone(), "\n", &mut output, None),
        };
        emitter.emit_module(module)?;
    }
    String::from_utf8(output).map_err(|e| anyhow::anyhow!("{e}"))
}

#[cfg(test)]
mod tests {
    use super::*;

    fn collect_atom_refs(source: &str, candidates: &[&str]) -> HashSet<Atom> {
        GLOBALS.set(&Default::default(), || {
            let cm: Lrc<SourceMap> = Default::default();
            let module = super::super::parse_es_module(source, "atom-ref-test.js", cm)
                .expect("test source should parse");
            let candidate_atoms: HashSet<Atom> =
                candidates.iter().map(|name| Atom::from(*name)).collect();
            let mut collector = AtomRefCollector {
                candidate_atoms: &candidate_atoms,
                references: HashSet::new(),
                shadowed_atoms: vec![HashSet::new()],
            };
            module.visit_with(&mut collector);
            collector.references
        })
    }

    #[test]
    fn atom_ref_collector_finds_unbound_candidate_refs() {
        let refs = collect_atom_refs(
            r#"
function read(q) {
    return JA(q);
}
var obj = { [JA]: true };
"#,
            &["JA"],
        );

        assert!(refs.contains(&Atom::from("JA")));
    }

    #[test]
    fn atom_ref_collector_skips_shadowed_refs_and_static_property_keys() {
        let refs = collect_atom_refs(
            r#"
function read(JA) {
    return JA;
}
var obj = { JA: true };
"#,
            &["JA"],
        );

        assert!(
            !refs.contains(&Atom::from("JA")),
            "parameter references and static object keys should not synthesize imports"
        );
    }

    #[test]
    fn import_augmentation_only_adds_specifiers_to_existing_sources() {
        let mut binding_to_filename = HashMap::new();
        binding_to_filename.insert((Atom::from("NT"), Default::default()), "NT.js".to_string());
        binding_to_filename.insert((Atom::from("JA"), Default::default()), "NT.js".to_string());
        binding_to_filename.insert(
            (Atom::from("Other"), Default::default()),
            "Other.js".to_string(),
        );
        let referenced_atoms = [Atom::from("JA"), Atom::from("Other")]
            .into_iter()
            .collect();
        let mut imports_by_source =
            HashMap::from([(String::from("NT.js"), vec![Atom::from("NT")])]);
        let binding_filename_by_atom = atom_to_filename_binding_map(&binding_to_filename);

        augment_imports_with_referenced_atoms_for_existing_sources(
            &mut imports_by_source,
            "D38_2.js",
            &referenced_atoms,
            &binding_filename_by_atom,
            None,
        );

        let nt_imports = imports_by_source.get("NT.js").unwrap();
        assert!(nt_imports.contains(&Atom::from("JA")));
        assert!(
            !imports_by_source.contains_key("Other.js"),
            "augmentation must not create new import edges"
        );
    }

    #[test]
    fn factory_atom_import_can_create_filename_edge() {
        let mut imports_by_filename = HashMap::new();
        let binding = (Atom::from("RT6"), Default::default());

        add_factory_atom_import(&mut imports_by_filename, "Zaq_2.js", &binding, "RT6.js");

        assert_eq!(
            imports_by_filename.get("RT6.js"),
            Some(&vec![binding.clone()])
        );

        add_factory_atom_import(&mut imports_by_filename, "RT6.js", &binding, "RT6.js");

        assert_eq!(
            imports_by_filename.get("RT6.js"),
            Some(&vec![binding]),
            "self imports should still be ignored"
        );
    }
}