fix(hir/codegen): cross-module class + array-method dispatch + Date instanceof

While porting Mango (a Perry app) to use the pure-TypeScript
`@perryts/mongodb` driver, several long-latent dispatch holes surfaced
once a real cross-module class graph was being compiled.  Each is fixed
at the level it manifests rather than worked around in user code.

- compile.rs: honour a `"perry"` exports condition in `package.json`
  so packages can ship TS source (`./src/index.ts`) for Perry-native
  compilation alongside a pre-built JS dist for Node/Bun consumers.

- compile.rs + codegen.rs: imported classes now carry
  `static_method_names`, populated from the source HIR's
  `class.static_methods`.  Codegen registers each entry in
  `method_names` keyed by `(effective_name, sm)` so
  `MyClass.connect(...)` on an imported class resolves to the
  source-side `_perry_static_<src>__<MyClass>__<connect>` symbol
  instead of falling through to `0.0`.  Matching no-op
  `__perry_extern_closure_<Class>` wrappers are emitted for class
  names so referencing the class as a value (instanceof, eq) doesn't
  fail at link time.

- lower.rs (`StaticMethodCall` candidate detection): treat any
  uppercase imported identifier as a candidate class so
  `Foo.connect(...)` on a cross-module class lowers to
  `Expr::StaticMethodCall` and reaches the `method_names` table above.
  Without this, the same call lowered to a `Call(PropertyGet(...))`
  shape that read garbage off the static `ClosureHeader` global and
  crashed.

- lower.rs (array-method fast path): add a class-instance / unknown
  receiver guard so `coll.find(filter)`, `xs.map(fn)`, etc. on a
  user-class instance no longer collapse to `Expr::ArrayFind` /
  `Expr::ArrayMap` and dispatch to `js_array_<method>` on a class
  handle — the runtime returned `0` and the smoke ended up calling
  `0.toArray()`.  An overlapping-method list (find / map / filter /
  forEach / reduce / some / every / join …) is the trigger; receivers
  whose static type is `Type::Any` plus one of those names now skip
  the array fast-path and fall through to method-dispatch resolution.

- js_transform.rs: cross-module pass propagates native-instance
  tagging through plain ident-rebinds (`let sock: Socket = plainSock`)
  via a fixed-point scan.  Without this, an explicit type annotation
  re-erased the `(net, Socket)` tag set on the source variable and
  the next `sock.on('data', cb)` skipped the native dispatcher and
  segfaulted reading `[handle - 8]`.

- date.rs + object.rs: `instanceof Date` previously returned `true`
  for every finite f64.  Add a thread-local `DATE_REGISTRY` of f64
  bit patterns produced by `js_date_new*` and consult it from the
  `js_instanceof` Date arm.  Restores the typed BSON-encoder
  dispatch that was mis-classifying `batchSize: 100` as a Date and
  rejecting the wire find command.

destructuring.rs: comment-only — points readers at the cross-module
js_transform pass that subsumes the variable-to-variable native
instance propagation that used to live here.

Tested end to end against MongoDB 7.0 from a perry-native binary:
connect, ping, listDatabases, insertOne, find().toArray(), findOne,
updateOne, deleteOne all roundtrip with correct ObjectId bytes.
Mango (92 modules) still compiles to a 9.4 MB native binary.

Author: proggeramlug

crates/perry-codegen/src/codegen.rs

@@ -167,6 +167,11 @@ pub struct ImportedClass {
     pub constructor_param_count: usize,
     /// Method names defined on this class.
     pub method_names: Vec<String>,
+    /// Static method names defined on this class. Without this, calls like
+    /// `MyClass.staticMethod(...)` on an imported class are treated as a
+    /// missing method and fall through to `0.0` — turning every
+    /// `await Foo.connect(...)` into a no-op that resolves with the number 0.
+    pub static_method_names: Vec<String>,
     /// Getter property names. Without these, cross-module `obj.prop` for a
     /// getter property silently falls through to `undefined` because the
     /// dispatch site at `expr.rs::PropertyGet` looks up `(class, "__get_prop")`
@@ -1009,6 +1014,27 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
             ctor_params.push(DOUBLE);
         }
         llmod.declare_function(&ctor_fn, VOID, &ctor_params);
+
+        // Cross-module static methods. Source module emits these as
+        // `perry_static_<source_prefix>__<class>__<method>` (no `this`
+        // receiver). Register them in `method_names` under the same
+        // (class, method) key the StaticMethodCall lowering looks up.
+        for sm in &ic.static_method_names {
+            let llvm_fn = format!(
+                "perry_static_{}__{}__{}",
+                sanitize(src),
+                sanitize(&ic.name),
+                sanitize(sm),
+            );
+            method_names
+                .entry((effective_name.to_string(), sm.clone()))
+                .or_insert_with(|| llvm_fn.clone());
+            // Declare conservatively with 6 double params; LLVM's direct-call
+            // resolution doesn't require an exact arity match for declarations.
+            let param_types: Vec<crate::types::LlvmType> =
+                std::iter::repeat(DOUBLE).take(6).collect();
+            llmod.declare_function(&llvm_fn, DOUBLE, &param_types);
+        }
     }
 
     // Resolve user function names up-front so body lowering can emit
@@ -1381,16 +1407,58 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
     {
         use std::collections::HashSet;
         let mut emitted_wrappers: HashSet<String> = HashSet::new();
+        // Build a quick lookup of imported class names (and their local aliases).
+        // Classes have no `perry_fn_<src>__<Class>` symbol — method/constructor/
+        // static dispatch happens via separate tables. For these we still need
+        // the `__perry_extern_closure_*` global (other code may load it as a
+        // value), but the wrapper body must NOT call a missing function: emit
+        // a no-op that returns `undefined` so any indirect call through the
+        // closure header fails closed instead of failing at link time.
+        let mut imported_class_names: HashSet<String> = HashSet::new();
+        for ic in &opts.imported_classes {
+            imported_class_names.insert(ic.name.clone());
+            if let Some(alias) = &ic.local_alias {
+                imported_class_names.insert(alias.clone());
+            }
+        }
         // Stable iteration order for deterministic IR output.
         let mut imports: Vec<(&String, &String)> =
             opts.import_function_prefixes.iter().collect();
         imports.sort_by(|a, b| a.0.cmp(b.0));
         for (name, source_prefix) in imports {
+            let is_class = imported_class_names.contains(name);
             let wrapper_name =
                 format!("__perry_wrap_extern_{}__{}", source_prefix, name);
             if !emitted_wrappers.insert(wrapper_name.clone()) {
                 continue;
             }
+            if is_class {
+                // No-op wrapper + a closure header that points at it. The
+                // wrapper returns NaN-tagged `undefined` so any indirect call
+                // (`MyClass.somethingThatIsActuallyAFn()`) returns undefined.
+                // Match the regular wrapper's calling convention — `%this_closure`
+                // followed by 6 double params — so direct calls in the IR don't
+                // tear off into garbage stack slots.
+                let mut wrap_params: Vec<(LlvmType, String)> = Vec::with_capacity(7);
+                wrap_params.push((I64, "%this_closure".to_string()));
+                for i in 0..6 {
+                    wrap_params.push((DOUBLE, format!("%a{}", i)));
+                }
+                let wf = llmod.define_function(&wrapper_name, DOUBLE, wrap_params);
+                wf.linkage = "internal".to_string();
+                let _ = wf.create_block("entry");
+                let blk = wf.block_mut(0).unwrap();
+                let undef = crate::nanbox::double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED));
+                blk.ret(DOUBLE, &undef);
+                let global_name =
+                    format!("__perry_extern_closure_{}__{}", source_prefix, name);
+                let init = format!(
+                    "{{ ptr @{}, i32 0, i32 1129074515 }}",
+                    wrapper_name
+                );
+                llmod.add_internal_constant(&global_name, "{ ptr, i32, i32 }", &init);
+                continue;
+            }
             let target_name = format!("perry_fn_{}__{}", source_prefix, name);
             // Look up the param count from the import metadata. Fall back
             // to 0 if missing — emits a no-arg wrapper, which is wrong

crates/perry-hir/src/destructuring.rs

@@ -1376,6 +1376,10 @@ pub(crate) fn lower_var_decl_with_destructuring(
                     }
                     _ => None,
                 };
+                // Variable-to-variable propagation for native instances
+                // (`let sock: Socket = plainSock`) is handled by the
+                // post-lowering cross-module pass; see
+                // `js_transform::scan_for_ident_init_propagation`.
                 if let Some(call_expr) = call_expr {
                     if let ast::Callee::Expr(callee_expr) = &call_expr.callee {
                         // Check direct function calls: const x = someFunc()

crates/perry-hir/src/js_transform.rs

@@ -976,6 +976,54 @@ pub fn fix_cross_module_native_instances(
         }
     }
 
+    // Variable-to-variable propagation: `let sock: Socket = plainSock` —
+    // run a fixed-point scan so each rebind of an already-tracked native
+    // instance keeps the dispatch information. Without this, a typed
+    // ident-rebind drops the (module, class) tag and `sock.on(...)`
+    // falls through to typed-interface dispatch on the small handle.
+    {
+        let mut changed = true;
+        while changed {
+            changed = false;
+            // Init block
+            for stmt in &module.init {
+                if scan_for_ident_init_propagation(stmt, &mut local_native_instances, &mut local_id_native_instances) {
+                    changed = true;
+                }
+            }
+            for func in &module.functions {
+                for stmt in &func.body {
+                    if scan_for_ident_init_propagation(stmt, &mut local_native_instances, &mut local_id_native_instances) {
+                        changed = true;
+                    }
+                }
+            }
+            for class in &module.classes {
+                if let Some(ctor) = &class.constructor {
+                    for stmt in &ctor.body {
+                        if scan_for_ident_init_propagation(stmt, &mut local_native_instances, &mut local_id_native_instances) {
+                            changed = true;
+                        }
+                    }
+                }
+                for method in &class.methods {
+                    for stmt in &method.body {
+                        if scan_for_ident_init_propagation(stmt, &mut local_native_instances, &mut local_id_native_instances) {
+                            changed = true;
+                        }
+                    }
+                }
+                for method in &class.static_methods {
+                    for stmt in &method.body {
+                        if scan_for_ident_init_propagation(stmt, &mut local_native_instances, &mut local_id_native_instances) {
+                            changed = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     if local_native_instances.is_empty() && local_id_native_instances.is_empty() {
         return;
     }
@@ -1093,6 +1141,104 @@ fn scan_for_native_func_returns(
     }
 }
 
+/// Scan a statement (recursively) for `let x = y` patterns where `y` is
+/// already a known native instance. When found, propagate the (module,
+/// class) tag to `x` so its later `.on(...) / .write(...)` dispatches go
+/// to the native runtime instead of the typed-interface fallback.
+///
+/// Returns `true` when at least one new propagation happened — the caller
+/// fixes a point by re-running until stable.
+fn scan_for_ident_init_propagation(
+    stmt: &Stmt,
+    local_native_instances: &mut HashMap<String, (String, String)>,
+    local_id_native_instances: &mut HashMap<perry_types::LocalId, (String, String)>,
+) -> bool {
+    let mut changed = false;
+    match stmt {
+        Stmt::Let { id, name, init, .. } => {
+            if let Some(init_expr) = init {
+                if let Some((module, class)) = lookup_native_from_init_ident(init_expr, local_native_instances, local_id_native_instances) {
+                    let info = (module, class);
+                    if local_native_instances.insert(name.clone(), info.clone()).is_none() {
+                        changed = true;
+                    }
+                    if local_id_native_instances.insert(*id, info).is_none() {
+                        changed = true;
+                    }
+                }
+            }
+        }
+        Stmt::If { then_branch, else_branch, .. } => {
+            for s in then_branch {
+                if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                    changed = true;
+                }
+            }
+            if let Some(else_stmts) = else_branch {
+                for s in else_stmts {
+                    if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                        changed = true;
+                    }
+                }
+            }
+        }
+        Stmt::While { body, .. } | Stmt::For { body, .. } => {
+            for s in body {
+                if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                    changed = true;
+                }
+            }
+        }
+        Stmt::Try { body, catch, finally } => {
+            for s in body {
+                if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                    changed = true;
+                }
+            }
+            if let Some(catch_block) = catch {
+                for s in &catch_block.body {
+                    if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                        changed = true;
+                    }
+                }
+            }
+            if let Some(finally_stmts) = finally {
+                for s in finally_stmts {
+                    if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                        changed = true;
+                    }
+                }
+            }
+        }
+        Stmt::Switch { cases, .. } => {
+            for case in cases {
+                for s in &case.body {
+                    if scan_for_ident_init_propagation(s, local_native_instances, local_id_native_instances) {
+                        changed = true;
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    changed
+}
+
+/// If the init expression resolves to a known native instance via a
+/// LocalGet (HIR's representation of an ident reference), return its
+/// (module, class). TS type casts are stripped at lowering time, so we
+/// only need to inspect LocalGet here.
+fn lookup_native_from_init_ident(
+    expr: &Expr,
+    _local_native_instances: &HashMap<String, (String, String)>,
+    local_id_native_instances: &HashMap<perry_types::LocalId, (String, String)>,
+) -> Option<(String, String)> {
+    if let Expr::LocalGet(id) = expr {
+        return local_id_native_instances.get(id).cloned();
+    }
+    None
+}
+
 /// Walk an expression for nested closures and scan their bodies. Catches
 /// `const sock = openSocket(...)` when wrapped in a closure passed to
 /// `new Promise(...)`, `setTimeout(...)`, callback args, etc.