fix: compile large TypeScript source graphs natively

changelog.d/8383-opencode-source-graphs.md

@@ -0,0 +1,3 @@
+Compile large TypeScript package graphs directly, preserving nested namespace,
+barrel-export, class-origin, asset, WebAssembly, and CommonJS linkage while
+keeping native-addon dependencies on explicit compatibility paths.

crates/perry-codegen/src/codegen/helpers.rs

@@ -1622,6 +1622,21 @@ pub(super) fn emit_namespace_populator(
                 NamespaceEntryKind::NestedNamespace { source_prefix } => ctx
                     .block()
                     .load(DOUBLE, &format!("@__perry_ns_{}", source_prefix)),
+                NamespaceEntryKind::NativeNamespace { specifier } => {
+                    let name = specifier.strip_prefix("node:").unwrap_or(specifier);
+                    let name_idx = ctx.strings.intern(name);
+                    let name_global = format!("@{}", ctx.strings.entry(name_idx).bytes_global);
+                    let name_len = name.len().to_string();
+                    let blk = ctx.block();
+                    if let Some(install) = crate::nm_install::nm_install_symbol(name) {
+                        blk.call_void(install, &[]);
+                    }
+                    blk.call(
+                        DOUBLE,
+                        "js_create_native_module_namespace",
+                        &[(PTR, &name_global), (I64, &name_len)],
+                    )
+                }
             };
 
             handles.push(group.adopt_emitted(ctx, crate::rooting::Repr::Boxed, &val_str, true));

crates/perry-codegen/src/codegen/mod.rs

@@ -195,6 +195,7 @@ pub(crate) mod helpers;
 mod method;
 mod method_registry;
 mod module_globals_emit;
+mod native_namespace_exports;
 #[cfg(test)]
 mod number_exactness_tests;
 mod opts;

crates/perry-codegen/src/codegen/module_globals_emit.rs

@@ -287,10 +287,24 @@ pub(crate) fn emit_module_globals(
     // dispatch instead of the class method registry.
     let mut module_global_types: HashMap<u32, perry_hir::types::Type> = HashMap::new();
     let mut module_global_proven_types: HashMap<u32, perry_hir::types::Type> = HashMap::new();
-    // Collect exported variable names so we can create external
-    // globals + getter functions for cross-module access.
-    let exported_var_names: std::collections::HashSet<String> =
-        hir.exported_objects.iter().cloned().collect();
+    // `exported_objects` contains both sides of renamed exports. Storage is
+    // owned by the local binding; deriving this set from the flat list can
+    // globalize an unrelated local that happens to have the public name.
+    let exported_object_names: std::collections::HashSet<&str> =
+        hir.exported_objects.iter().map(String::as_str).collect();
+    let exported_var_names: std::collections::HashSet<String> = hir
+        .exports
+        .iter()
+        .filter_map(|export| match export {
+            perry_hir::Export::Named { local, exported }
+                if exported_object_names.contains(local.as_str())
+                    || exported_object_names.contains(exported.as_str()) =>
+            {
+                Some(local.clone())
+            }
+            _ => None,
+        })
+        .collect();
     // #6649: module-level array-destructuring declarations (`var [Prime, Size]
     // = [BigInt(...), BigInt(...)]` — TypeBox's FNV-1a table in the pi bundle)
     // lower their leaf `Stmt::Let`s inside the iterator-protocol `Stmt::Try`
@@ -415,14 +429,25 @@ pub(crate) fn emit_module_globals(
                 // emitting a getter here on top would be a redef and is
                 // semantically wrong (it'd return the closure value instead
                 // of invoking it).
-                let is_function_alias = hir.exported_functions.iter().any(|(exp, _)| exp == name);
+                let is_function_alias = hir.exported_functions.iter().any(|(exp, _)| exp == name)
+                    || hir.exports.iter().any(|export| match export {
+                        perry_hir::Export::Named { local, exported } if local == name => hir
+                            .exported_functions
+                            .iter()
+                            .any(|(function_export, _)| function_export == exported),
+                        _ => false,
+                    });
                 if is_exported && !is_also_function && !is_function_alias {
-                    let fn_name = format!("perry_fn_{}__{}", module_prefix, sanitize(name),);
-                    let getter = llmod.define_function(&fn_name, DOUBLE, vec![]);
-                    let _ = getter.create_block("entry");
-                    let blk = getter.block_mut(0).unwrap();
-                    let val = blk.load(DOUBLE, &format!("@{}", global_name));
-                    blk.ret(DOUBLE, &val);
+                    let public_names: std::collections::BTreeSet<&str> = hir
+                        .exports
+                        .iter()
+                        .filter_map(|export| match export {
+                            perry_hir::Export::Named { local, exported } if local == name => {
+                                Some(exported.as_str())
+                            }
+                            _ => None,
+                        })
+                        .collect();
 
                     // #460: also emit a duplicate getter under any renamed
                     // export targeting this local. `export { _await as await }`
@@ -433,20 +458,46 @@ pub(crate) fn emit_module_globals(
                     // returns; callers that invoke it as a function get the
                     // closure handle (matching status quo for non-renamed
                     // `export const f = aFunctionRef` exports).
-                    for export in &hir.exports {
-                        if let perry_hir::Export::Named { local, exported } = export {
-                            if local == name && exported != name {
-                                let alias_fn =
-                                    format!("perry_fn_{}__{}", module_prefix, sanitize(exported));
-                                if alias_fn == fn_name {
-                                    continue;
-                                }
-                                let g = llmod.define_function(&alias_fn, DOUBLE, vec![]);
-                                let _ = g.create_block("entry");
-                                let b = g.block_mut(0).unwrap();
-                                let v = b.load(DOUBLE, &format!("@{}", global_name));
-                                b.ret(DOUBLE, &v);
-                            }
+                    for public_name in public_names {
+                        let getter_name =
+                            format!("perry_fn_{}__{}", module_prefix, sanitize(public_name));
+                        if !llmod.has_function(&getter_name) {
+                            let getter = llmod.define_function(&getter_name, DOUBLE, vec![]);
+                            let _ = getter.create_block("entry");
+                            let blk = getter.block_mut(0).unwrap();
+                            let val = blk.load(DOUBLE, &format!("@{}", global_name));
+                            blk.ret(DOUBLE, &val);
+                        }
+
+                        // Import-origin metadata preserves the raw exported
+                        // spelling. For identifiers such as `$i`, consumers
+                        // therefore reference `perry_fn_<mod>__$i`, while the
+                        // historical getter above uses the plain sanitizer
+                        // (`_i`). Mirror the function-export alias rule and
+                        // forward the raw spelling to the canonical getter.
+                        let raw_getter_name =
+                            format!("perry_fn_{}__{}", module_prefix, public_name);
+                        if raw_getter_name != getter_name && !llmod.has_function(&raw_getter_name) {
+                            let alias = llmod.define_function(&raw_getter_name, DOUBLE, vec![]);
+                            let _ = alias.create_block("entry");
+                            let blk = alias.block_mut(0).unwrap();
+                            let val = blk.call(DOUBLE, &getter_name, &[]);
+                            blk.ret(DOUBLE, &val);
+                        }
+
+                        // Re-export origin metadata can instead preserve the
+                        // raw LOCAL spelling (`export { $i as filesFilter }`).
+                        // Forward that spelling to the same public getter too.
+                        let raw_local_getter_name = format!("perry_fn_{}__{}", module_prefix, name);
+                        if raw_local_getter_name != getter_name
+                            && !llmod.has_function(&raw_local_getter_name)
+                        {
+                            let alias =
+                                llmod.define_function(&raw_local_getter_name, DOUBLE, vec![]);
+                            let _ = alias.create_block("entry");
+                            let blk = alias.block_mut(0).unwrap();
+                            let val = blk.call(DOUBLE, &getter_name, &[]);
+                            blk.ret(DOUBLE, &val);
                         }
                     }
                 }

crates/perry-codegen/src/codegen/native_namespace_exports.rs

@@ -0,0 +1,52 @@
+//! Runtime getters for namespace re-exports of Perry-native modules.
+
+use perry_hir::Module as HirModule;
+
+use crate::module::LlModule;
+use crate::types::{DOUBLE, I64, PTR};
+
+pub(super) fn emit_native_namespace_reexport_getters(
+    llmod: &mut LlModule,
+    hir: &HirModule,
+    module_prefix: &str,
+) {
+    // A namespace re-export of a compiler-native module has no compiled
+    // source module (and therefore no `@__perry_ns_<prefix>` global) behind
+    // it. Expose it as a zero-argument value getter on the re-exporting module
+    // so ordinary named imports can materialize the runtime-native namespace:
+    //
+    //   export * as NodeWS from "ws"
+    //   import { NodeWS } from "./NodeSocket"
+    //
+    // The driver classifies the consumer binding as `imported_vars`, so its
+    // ExternFuncRef value path calls this getter rather than creating a closure
+    // around a nonexistent function export.
+    for export in &hir.exports {
+        let perry_hir::Export::NamespaceReExport { source, name } = export else {
+            continue;
+        };
+        if !perry_hir::NATIVE_MODULES.contains(&source.strip_prefix("node:").unwrap_or(source)) {
+            continue;
+        }
+        let getter_name = format!("perry_fn_{}__{}", module_prefix, name);
+        if llmod.has_function(&getter_name) {
+            continue;
+        }
+        let (source_global, source_len) = llmod.add_string_constant(source);
+        let getter = llmod.define_function(&getter_name, DOUBLE, vec![]);
+        let _ = getter.create_block("entry");
+        let blk = getter.block_mut(0).unwrap();
+        if let Some(install) = crate::nm_install::nm_install_symbol(source) {
+            blk.call_void(install, &[]);
+        }
+        let value = blk.call(
+            DOUBLE,
+            "js_create_native_module_namespace",
+            &[
+                (PTR, &format!("@{}", source_global)),
+                (I64, &source_len.to_string()),
+            ],
+        );
+        blk.ret(DOUBLE, &value);
+    }
+}

crates/perry-codegen/src/codegen/opts.rs

@@ -460,11 +460,10 @@ pub enum NamespaceEntryKind {
         source_prefix: String,
         source_local: String,
     },
-    /// Re-exported function from another module. Codegen declares the
-    /// target's `perry_fn_*` as extern, emits a per-callsite
-    /// `__perry_wrap_extern_*` thin wrapper (if not already emitted by
-    /// the import-wrapper pass), and calls
-    /// `js_closure_alloc_singleton` against that wrapper.
+    /// Re-exported function from another module. The namespace populator
+    /// declares the target's `perry_fn_*`, emits its own
+    /// `__perry_wrap_extern_*` thunk, and calls `js_closure_alloc_singleton`
+    /// against that wrapper.
     ForeignFunction {
         source_prefix: String,
         source_local: String,
@@ -474,6 +473,10 @@ pub enum NamespaceEntryKind {
     /// nested value IS the target module's `@__perry_ns_<source_prefix>`
     /// global, populated by the target's own `__init`.
     NestedNamespace { source_prefix: String },
+    /// `export * as Name from "node:..."` (or another Perry-native module).
+    /// Native modules have no compiled `@__perry_ns_*` global, so codegen asks
+    /// the runtime to materialize their namespace directly.
+    NativeNamespace { specifier: String },
 }
 
 /// A class imported from another native module.

crates/perry-codegen/src/expr/dyn_extern_i18n.rs

@@ -763,14 +763,10 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
         // an imported function appears as a STANDALONE value — `if
         // (this.ffi.setCursors)` truthiness check, `someFn === otherFn`
         // equality comparison, or being passed as a callback — we route
-        // to the static `__perry_extern_closure_<src>__<name>` global
-        // emitted by `compile_module` for every imported function (see the
-        // wrapper-emit block right after the user-function `__perry_wrap_*`
-        // loop). The global is a `ClosureHeader` with `func_ptr` pointing
-        // at a thin `__perry_wrap_extern_<src>__<name>` thunk and
-        // `type_tag = CLOSURE_MAGIC`, so the runtime's `js_closure_callN`
-        // sees a valid closure and dispatches correctly. We just take the
-        // address and NaN-box it as POINTER.
+        // to the source module's canonical `__perry_wrap_perry_fn_*` symbol
+        // and ask `js_closure_alloc_singleton` for its shared ClosureHeader.
+        // This preserves reference identity across consumers without emitting
+        // a second consumer-local wrapper for every imported binding.
         //
         // For namespaces / built-ins that aren't in `import_function_prefixes`
         // (e.g. setTimeout / clearTimeout / Math / Date), we still don't

crates/perry-codegen/src/expr/mod.rs

@@ -1827,6 +1827,45 @@ pub(crate) fn class_field_loop_fact_lookup<'f>(
     })
 }
 
+/// Build a linker-unique inline-cache global name.
+///
+/// `ic_site_counter` is only module-wide. LLVM codegen-unit splitting can
+/// promote a private global for cross-unit use, so the source-module prefix is
+/// also required to keep separately compiled modules from defining the same
+/// `perry_ic_N` symbol at the final application link.
+pub(crate) fn inline_cache_global_name(ctx: &FnCtx<'_>, site_id: u32) -> String {
+    inline_cache_global_name_for_prefix(ctx.strings.module_prefix(), site_id)
+}
+
+fn inline_cache_global_name_for_prefix(module_prefix: &str, site_id: u32) -> String {
+    if module_prefix.is_empty() {
+        format!("perry_ic_{site_id}")
+    } else {
+        format!("perry_ic_{module_prefix}__{site_id}")
+    }
+}
+
+#[cfg(test)]
+mod inline_cache_name_tests {
+    use super::inline_cache_global_name_for_prefix;
+
+    #[test]
+    fn cache_symbols_are_unique_across_source_modules() {
+        assert_eq!(
+            inline_cache_global_name_for_prefix("packages_a_ts", 7),
+            "perry_ic_packages_a_ts__7"
+        );
+        assert_eq!(
+            inline_cache_global_name_for_prefix("packages_b_ts", 7),
+            "perry_ic_packages_b_ts__7"
+        );
+        assert_ne!(
+            inline_cache_global_name_for_prefix("packages_a_ts", 7),
+            inline_cache_global_name_for_prefix("packages_b_ts", 7)
+        );
+    }
+}
+
 impl<'a> FnCtx<'a> {
     /// Return runtime-derived initializer evidence only when no write anywhere
     /// in this region can have invalidated it.

crates/perry-codegen/src/expr/property_get/generic_dispatch.rs

@@ -86,7 +86,7 @@ pub(crate) fn lower_generic_property_get(
         // unchanged.
         let cache_site = ctx.ic_site_counter;
         ctx.ic_site_counter += 1;
-        let cache_name = format!("perry_ic_{}", cache_site);
+        let cache_name = super::super::inline_cache_global_name(ctx, cache_site);
         ctx.pending_declares
             .push((format!("__ic_decl_{}", cache_site), DOUBLE, vec![]));
         ctx.ic_globals.push(cache_name.clone());
@@ -262,7 +262,7 @@ pub(crate) fn lower_generic_property_get(
     // full lookup and primes the cache for next time.
     let site_id = ctx.ic_site_counter;
     ctx.ic_site_counter += 1;
-    let cache_name = format!("perry_ic_{}", site_id);
+    let cache_name = super::super::inline_cache_global_name(ctx, site_id);
     ctx.pending_declares
         .push((format!("__ic_decl_{}", site_id), DOUBLE, vec![]));
     ctx.ic_globals.push(cache_name.clone());

crates/perry-codegen/src/expr/proxy_reflect.rs

@@ -480,15 +480,15 @@ fn lower_put_value_static_write_ic(
 
     let site_id = ctx.ic_site_counter;
     ctx.ic_site_counter += 1;
-    let cache_name = format!("perry_ic_{}", site_id);
+    let cache_name = super::inline_cache_global_name(ctx, site_id);
     ctx.pending_declares
         .push((format!("__ic_decl_{}", site_id), DOUBLE, vec![]));
     ctx.ic_globals.push(cache_name.clone());
     let cache_ref = format!("@{}", cache_name);
     // Keep the first four ways inline. Shapes 5–8 use a separate cache in a
     // compact outlined helper, avoiding four more copies of the generated
     // receiver guards while preventing the fourth inline way from thrashing.
-    let tail_cache_name = format!("perry_ic_{}_poly_tail", site_id);
+    let tail_cache_name = format!("{}_poly_tail", cache_name);
     ctx.ic_globals.push(tail_cache_name.clone());
     let tail_cache_ref = format!("@{}", tail_cache_name);
 
@@ -884,7 +884,7 @@ fn lower_put_value_dyn_ic_inline(
 ) -> Result<String> {
     let site_id = ctx.ic_site_counter;
     ctx.ic_site_counter += 1;
-    let cache_name = format!("perry_ic_{}", site_id);
+    let cache_name = super::inline_cache_global_name(ctx, site_id);
     ctx.ic_globals.push(cache_name.clone());
     let cache_ref = format!("@{}", cache_name);
 
@@ -1653,7 +1653,7 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                     let t = g.reread(ctx, recv_slot)?;
                     let site_id = ctx.ic_site_counter;
                     ctx.ic_site_counter += 1;
-                    let cache_name = format!("perry_ic_{}", site_id);
+                    let cache_name = super::inline_cache_global_name(ctx, site_id);
                     ctx.ic_globals.push(cache_name.clone());
                     let cache_ref = format!("@{}", cache_name);
                     Ok(ctx.block().call(