fix(cjs): preserve live getter re-export bindings

changelog.d/10153-cjs-getter-reexport-binding.md

@@ -0,0 +1,12 @@
+### Fixed
+
+- Recognize CommonJS exports installed with `Object.defineProperty`, including
+  Babel's getter re-exports, as value exports. ESM named and namespace imports
+  now read the current property through the existing getter-aware runtime
+  lookup and call the returned value, instead of referencing a function symbol
+  that the CommonJS barrel never defined.
+- Avoid evaluating synthetic CommonJS property exports during initialization,
+  preserving accessor side effects and exports assigned or replaced later.
+  Regression coverage includes named imports, namespace calls, ESM barrels,
+  materialized and dynamic namespaces, writable descriptors, and late
+  assignments (#10153).

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

@@ -1955,5 +1955,7 @@ pub(super) fn emit_module_artifacts(c: ModuleArtifactsCtx<'_>) -> Result<()> {
     );
     progress.checkpoint("string pool and registration initializer");
 
+    super::namespace_value_getters::emit(llmod, module_prefix, cross_module);
+
     Ok(())
 }

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

@@ -0,0 +1,123 @@
+//! Turn the CJS wrapper's synthetic property exports into live value getters.
+
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
+
+use perry_hir::{Expr, Module, Stmt};
+
+use crate::module::LlModule;
+use crate::types::{DOUBLE, I32, I64, PTR};
+
+pub(super) type PropertyExports = HashMap<String, (u32, String)>;
+
+/// The wrapper emits `export const x = _cjs.x` to register value-export
+/// metadata. Do not execute that read during module initialization: it can
+/// invoke a getter too early and freezes exports assigned after initialization.
+/// Keep the caller's HIR immutable (it is also the object-cache input).
+pub(super) fn prepare(hir: &Module) -> (Cow<'_, Module>, PropertyExports) {
+    // Pair the wrapper's private binding with its compiler-owned preamble;
+    // an ordinary ESM variable named `_cjs` still has snapshot semantics.
+    let has_preamble = hir.imports.iter().any(|import| {
+        import
+            .source
+            .strip_prefix("node:")
+            .unwrap_or(&import.source)
+            == "module"
+            && import.specifiers.iter().any(|specifier| {
+                matches!(specifier, perry_hir::ImportSpecifier::Named { imported, local }
+                    if imported == "createRequire" && local == "__perry_cjs_create_require")
+            })
+    });
+    if !has_preamble {
+        return (Cow::Borrowed(hir), HashMap::new());
+    }
+    let entry = super::entry_outline::logical_entry_stmts(hir);
+    let Some(object_id) = entry.iter().find_map(|stmt| match stmt {
+        Stmt::Let { id, name, .. } if name == "_cjs" => Some(*id),
+        _ => None,
+    }) else {
+        return (Cow::Borrowed(hir), HashMap::new());
+    };
+    let exported: HashSet<&str> = hir
+        .exports
+        .iter()
+        .filter_map(|export| match export {
+            perry_hir::Export::Named { local, .. } => Some(local.as_str()),
+            _ => None,
+        })
+        .collect();
+    let mut properties = HashMap::new();
+    let mut bindings = HashSet::new();
+    for stmt in entry {
+        if let Stmt::Let {
+            id,
+            name,
+            init: Some(Expr::PropertyGet {
+                object, property, ..
+            }),
+            ..
+        } = stmt
+        {
+            if exported.contains(name.as_str())
+                && matches!(object.as_ref(), Expr::LocalGet(id) if *id == object_id)
+            {
+                properties.insert(name.clone(), (object_id, property.clone()));
+                bindings.insert(*id);
+            }
+        }
+    }
+    if properties.is_empty() {
+        return (Cow::Borrowed(hir), properties);
+    }
+    let mut owned = hir.clone();
+    let clear_snapshots = |stmts: &mut [Stmt]| {
+        for stmt in stmts {
+            if let Stmt::Let { id, init, .. } = stmt {
+                if bindings.contains(id) {
+                    *init = None;
+                }
+            }
+        }
+    };
+    clear_snapshots(&mut owned.init);
+    for function in &mut owned.functions {
+        if super::entry_outline::is_entry_chunk(function) {
+            clear_snapshots(&mut function.body);
+        }
+    }
+    (Cow::Owned(owned), properties)
+}
+
+pub(super) fn emit_getter(
+    llmod: &mut LlModule,
+    getter_name: &str,
+    module_prefix: &str,
+    object_id: u32,
+    property: &str,
+) {
+    let (key_global, key_len) = llmod.add_string_constant(property);
+    let getter = llmod.define_function(getter_name, DOUBLE, vec![]);
+    getter.create_block("entry");
+    let blk = getter.block_mut(0).unwrap();
+    // Allocate the key before loading the GC-rooted namespace. No raw object
+    // pointer survives that allocation; the boxed property helper handles
+    // accessors, prototypes and function-valued module.exports.
+    let key = blk.call(
+        I64,
+        "js_string_from_bytes",
+        &[
+            (PTR, &format!("@{key_global}")),
+            (I32, &key_len.to_string()),
+        ],
+    );
+    let object = blk.load(
+        DOUBLE,
+        &format!("@perry_global_{module_prefix}__{object_id}"),
+    );
+    let value = blk.call(
+        DOUBLE,
+        "js_object_get_field_by_name_boxed",
+        &[(DOUBLE, &object), (I64, &key)],
+    );
+    blk.ret(DOUBLE, &value);
+}

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

@@ -182,6 +182,7 @@ mod artifact_display_names;
 mod artifact_source_text;
 mod artifacts;
 mod boxed_locals;
+mod cjs_exports;
 #[cfg(test)]
 mod clone_suffix_tests;
 mod closure;
@@ -213,6 +214,7 @@ mod method;
 mod method_registry;
 mod method_trampolines;
 mod module_globals_emit;
+pub(crate) mod namespace_value_getters;
 mod native_namespace_exports;
 #[cfg(test)]
 mod number_exactness_tests;
@@ -410,6 +412,8 @@ pub fn user_function_symbol(module_name: &str, function_name: &str) -> String {
 /// guarantee — do not change to `&mut` without also moving the cache
 /// hash to AFTER codegen.
 pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>> {
+    let (live_cjs_hir, cjs_property_exports) = cjs_exports::prepare(hir);
+    let hir = live_cjs_hir.as_ref();
     let progress = CompileProgress::new(&hir.name, module_callable_count(hir));
     let triple = opts.target.clone().unwrap_or_else(default_target_triple);
     let fp_flags = crate::block::FpFlags::new(opts.fast_math, opts.fp_contract_mode);
@@ -2731,6 +2735,7 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
         &opts.imported_classes,
         &cross_module.compile_time_constants,
         &module_prefix,
+        &cjs_property_exports,
     );
     cross_module.module_global_proven_types = module_global_proven_types;
 

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

@@ -160,6 +160,7 @@ pub(crate) fn emit_module_globals(
     imported_classes: &[ImportedClass],
     compile_time_constants: &HashMap<u32, f64>,
     module_prefix: &str,
+    cjs_property_exports: &super::cjs_exports::PropertyExports,
 ) -> ModuleGlobals {
     // Module-level globals registry. Pre-walk:
     //   1. Collect every LocalId referenced from any function or method
@@ -170,6 +171,9 @@ pub(crate) fn emit_module_globals(
     //      as cheap stack alloca (preserves perf for the bench
     //      benchmarks that don't share state with helper functions).
     let mut referenced_from_fn: std::collections::HashSet<u32> = std::collections::HashSet::new();
+    // Live CJS value getters read the namespace even after its synthetic
+    // snapshot initializers have been removed.
+    referenced_from_fn.extend(cjs_property_exports.values().map(|(id, _)| *id));
     // Helper that handles "params + lets define a scope, refs minus
     // defines flow out". Used for every function/method/closure body.
     let scan_body = |params: &[perry_hir::Param],
@@ -505,11 +509,21 @@ pub(crate) fn emit_module_globals(
                         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);
+                            if let Some((object_id, property)) = cjs_property_exports.get(name) {
+                                super::cjs_exports::emit_getter(
+                                    llmod,
+                                    &getter_name,
+                                    module_prefix,
+                                    *object_id,
+                                    property,
+                                );
+                            } else {
+                                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

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

@@ -0,0 +1,41 @@
+//! Closure-ABI adapters for live exports in materialized static namespaces.
+
+use super::helpers::sanitize_member;
+use super::opts::CrossModuleCtx;
+use crate::module::LlModule;
+use crate::types::{DOUBLE, I64};
+
+pub(crate) fn symbol(module_prefix: &str, namespace: &str, member: &str) -> String {
+    format!(
+        "__perry_namespace_value_{}__{}",
+        module_prefix,
+        sanitize_member(&format!("{namespace}:{member}"))
+    )
+}
+
+pub(super) fn emit(llmod: &mut LlModule, module_prefix: &str, imports: &CrossModuleCtx) {
+    let mut members: Vec<_> = imports.namespace_member_prefixes.iter().collect();
+    members.sort_by_key(|(key, _)| *key);
+    for ((namespace, member), source_prefix) in members {
+        let wrapper_name = symbol(module_prefix, namespace, member);
+        // Lowering declares an adapter only when a namespace value actually
+        // escapes. Direct `ns.x` reads need no additional wrapper.
+        if !llmod.is_declared(&wrapper_name) || llmod.has_function(&wrapper_name) {
+            continue;
+        }
+        let origin = crate::expr::import_origin_suffix_ns(
+            &imports.import_function_origin_names,
+            &imports.namespace_member_origin_names,
+            namespace,
+            member,
+        );
+        let getter_name = format!("perry_fn_{source_prefix}__{origin}");
+        llmod.declare_function(&getter_name, DOUBLE, &[]);
+        let wrapper =
+            llmod.define_function(wrapper_name, DOUBLE, vec![(I64, "%closure".to_string())]);
+        wrapper.create_block("entry");
+        let block = wrapper.block_mut(0).unwrap();
+        let value = block.call(DOUBLE, &getter_name, &[]);
+        block.ret(DOUBLE, &value);
+    }
+}

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

@@ -8,7 +8,7 @@ use anyhow::{anyhow, bail, Result};
 use perry_hir::types::Type as HirType;
 use perry_hir::Expr;
 
-use crate::nanbox::{double_literal, POINTER_MASK_I64};
+use crate::nanbox::double_literal;
 use crate::rooting::{with_rooted_accumulator, with_rooted_group, Arg, Repr};
 use crate::types::{DOUBLE, I32, I64, PTR};
 
@@ -436,9 +436,10 @@ fn materialize_compiled_namespace(ctx: &mut FnCtx<'_>, name: &str) -> Result<Opt
     let object = ctx
         .block()
         .call(I64, "js_object_alloc", &[(I32, &zero), (I32, &count)]);
+    let object = nanbox_pointer_inline(ctx.block(), &object);
     with_rooted_accumulator(
         ctx,
-        Repr::Ptr,
+        Repr::Boxed,
         &object,
         true,
         |ctx, accumulator| {
@@ -452,29 +453,53 @@ fn materialize_compiled_namespace(ctx: &mut FnCtx<'_>, name: &str) -> Result<Opt
                     }),
                     property: member.clone(),
                 };
-                let value = lower_expr(ctx, &member_get)?;
+                // #10153: materializing `ns` must not snapshot a variable
+                // export or invoke a CJS getter. Install a closure that reads
+                // the producer's value getter on each subsequent access.
+                let is_live = ctx
+                    .imported_vars
+                    .contains(&crate::namespace_member_var_key(name, member))
+                    && !ctx
+                        .namespace_member_nested
+                        .contains(&(name.to_string(), member.clone()));
+                let value = if is_live {
+                    let wrapper = crate::codegen::namespace_value_getters::symbol(
+                        ctx.strings.module_prefix(),
+                        name,
+                        member,
+                    );
+                    ctx.pending_declares
+                        .push((wrapper.clone(), DOUBLE, vec![I64]));
+                    let handle = ctx.block().call(
+                        I64,
+                        "js_closure_alloc_singleton",
+                        &[(PTR, &format!("@{wrapper}"))],
+                    );
+                    nanbox_pointer_inline(ctx.block(), &handle)
+                } else {
+                    lower_expr(ctx, &member_get)?
+                };
                 let key_index = ctx.strings.intern(member);
                 let key_global = format!("@{}", ctx.strings.entry(key_index).handle_global);
-                let key = {
-                    let block = ctx.block();
-                    let key = block.load(DOUBLE, &key_global);
-                    let key_bits = block.bitcast_double_to_i64(&key);
-                    block.and(I64, &key_bits, POINTER_MASK_I64)
-                };
-                accumulator.call_void(
+                let key = ctx.block().load(DOUBLE, &key_global);
+                accumulator.call(
                     ctx,
-                    "js_object_set_field_by_name",
-                    &[Arg::Plain(I64, &key), Arg::Plain(DOUBLE, &value)],
+                    DOUBLE,
+                    if is_live {
+                        "js_object_define_get_accessor"
+                    } else {
+                        "js_object_set_property_key"
+                    },
+                    &[Arg::Plain(DOUBLE, &key), Arg::Plain(DOUBLE, &value)],
                 );
             }
             Ok(())
         },
         |ctx, object| {
-            let value = nanbox_pointer_inline(ctx.block(), object);
             Ok(Some(ctx.block().call(
                 DOUBLE,
                 "js_finalize_namespace",
-                &[(DOUBLE, &value)],
+                &[(DOUBLE, object)],
             )))
         },
     )

crates/perry/src/commands/compile/cjs_wrap/detect.rs

@@ -62,7 +62,11 @@ pub(in crate::commands::compile) fn is_commonjs(source: &str) -> bool {
         // — no `exports.X =`, no `require(`. Without this arm they fall
         // through to the ESM pipeline, where the bare `exports` identifier
         // throws a ReferenceError at module init.
-        || stripped.contains("defineProperty(exports,")
+        || perry_perex::tooling::Regex::new(
+            r"(?:^|[^A-Za-z0-9_$.])Object\s*\.\s*defineProperty\s*\(\s*(?:module\s*\.\s*)?exports\s*,",
+        )
+        .unwrap()
+        .is_match(&stripped)
     {
         return true;
     }

crates/perry/src/commands/compile/cjs_wrap/extract_exports.rs

@@ -385,7 +385,8 @@ pub fn extract_object_literal_exports_from_require(source: &str) -> Vec<(String,
     out
 }
 
-/// Extract named-export patterns from CJS source. Three shapes are matched:
+/// Extract named-export patterns from CJS source. These are value bindings,
+/// including properties installed by accessors or by later function calls.
 ///
 ///   1. `exports.X = ...` and `module.exports.X = ...` — the canonical CJS
 ///      named-export form. Skips `__esModule` (the interop marker injected
@@ -463,6 +464,23 @@ pub fn extract_exports_from_source(source: &str) -> Vec<String> {
         }
     }
 
+    // #10153: Babel emits accessor re-exports with defineProperty rather
+    // than an assignment. A descriptor's `get` or `value` may hold a function,
+    // but that is not a function declaration in this module. Surface the name
+    // through the same value-export path as ordinary exports assignments.
+    let descriptor_re = perry_perex::tooling::Regex::new(
+        r#"(?:^|[^A-Za-z0-9_$.])(Object\s*\.\s*defineProperty\s*\(\s*(?:module\s*\.\s*)?exports\s*,\s*['"]([A-Za-z_$][A-Za-z0-9_$]*)['"]\s*,)"#,
+    )
+    .unwrap();
+    let stripped = detect::strip_comments_and_strings(source);
+    for cap in descriptor_re.captures_iter(source) {
+        let call = cap.get(1).unwrap();
+        // Ignore examples embedded in comments and strings.
+        if stripped[call.start()..].starts_with("Object") {
+            push_unique(&mut names, cap.get(2).unwrap().as_str());
+        }
+    }
+
     // Shape 2: `module.exports = { ... }` — extract every key from the
     // object literal body. Brace-balanced scan because the body may contain
     // nested braces (`module.exports = { fn: function() {} }`). Two key