fix(next): pass production App Route dylib gate

changelog.d/8082-next-production-app-route.md

@@ -0,0 +1,40 @@
+### Fixed
+
+- Preserve production Next.js App Route request state through generated
+  `AppRouteRouteModule.handle` dispatch, imported handlers, async
+  continuations, and separately loaded runtime/stdlib providers (#8036).
+
+- Keep native statepoint roots in an app dylib. The demotion of
+  `--output-type dylib` artifacts to the shared shadow stack predated
+  #8081's loaded-image stack-map indexing; with that in place it would
+  leave provider apps running a lowering production never ships, and it
+  defeated #8081's own gate assertion that the app's map survives macOS
+  dead stripping.
+
+- Class-self lowering respects a same-named method parameter or local
+  instead of forcing the lexical class binding; computed `require(".")` /
+  `require("..")` resolve relative to the caller; dynamic virtual dispatch
+  builds its direct-call ABI from the selected override's own metadata,
+  including rest and synthetic `arguments` shape in both override
+  directions; bound-method construction roots the receiver across closure
+  allocation and the closure across allocating metadata installation;
+  malformed unwind-table records are parsed transactionally with checked
+  ranges and offsets.
+
+### Added
+
+- A pinned Next 16.3.0 production App Route fixture
+  (`tests/release/packages/next-app-route/`): the untouched webpack output
+  is compiled as an app-only dylib against separate runtime and stdlib
+  provider images, then served through a `dlopen` host and compared with
+  the Node production oracle over 10 cold starts, each running two
+  21-request verifier passes. Half the cold starts run under forced
+  evacuation with GC diagnostics, and their moving-GC liveness is asserted
+  by `scripts/gc_evacuation_liveness_assert.py`, so zero copying minors or
+  zero copied objects is a hard failure rather than a vacuous pass.
+
+- `PERRY_GC_PROTECT_FROMSPACE_HOLDERS=1`: at a from-space fault, sweep the
+  whole live heap for any word that still decodes to the faulting address
+  and name the owners. The existing report answers "who used it" — the
+  consumer, which for a value read out of a table one instruction earlier
+  is never the bug; this answers "who kept it".

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

@@ -981,6 +981,7 @@ pub(super) fn compile_closure(
         imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
         method_param_counts: &cross_module.method_param_counts,
         method_has_rest: &cross_module.method_has_rest,
+        method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
         imported_func_return_types: &cross_module.imported_func_return_types,
         ffi_signatures: &cross_module.ffi_signatures,
         ffi_aliases: &cross_module.ffi_aliases,

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

@@ -461,6 +461,12 @@ pub(super) fn compile_module_entry(
         // `.next/server/**` module path now (before `main` borrows `llmod`); the
         // registration calls go in the block below. `(string_const_name,
         // byte_len, sanitized_prefix)`.
+        // Library entries need the same registry as executables. The host owns
+        // the event loop for a dylib, but `perry_module_init` still owns module
+        // initialization. In particular, a production Next App Route reaches
+        // its webpack chunks through runtime-computed `require(absolutePath)`
+        // calls after `perry_module_init` returns. Omitting these registrations
+        // makes the first dynamic import fail only in the shared-library path.
         let nextjs_path_inits: Vec<(String, usize, String)> = cross_module
             .nextjs_path_init_modules
             .iter()
@@ -630,18 +636,13 @@ pub(super) fn compile_module_entry(
             if !nextjs_path_inits.is_empty() {
                 blk.call_void("js_globalthis_seed_async_local_storage", &[]);
             }
-            for prefix in non_entry_module_prefixes {
-                if cross_module.deferred_module_prefixes.contains(prefix) {
-                    continue;
-                }
-                blk.call_void(&format!("{}__init", prefix), &[]);
-            }
-            // Next.js wall 54 (part 2): record each Deferred `.next/server/**`
-            // module's `__init` address under its absolute path so a runtime
-            // `require(absolutePath)` (turbopack page/chunk loading) can trigger
-            // its init lazily. No init runs here — only the address is recorded.
-            // The `<prefix>__init` symbols are already declared above for every
-            // non-entry prefix, so `ptrtoint` of the symbol resolves at link.
+            // Register Deferred runtime modules BEFORE eager module init. A
+            // production webpack runtime can execute a computed relative
+            // `require("./chunks/" + id)` from its own eager initializer; that
+            // chunk must already have an init address in the registry at that
+            // point. Registering after this loop made the same route work when
+            // loaded later by server.js but fail when its production handler
+            // bundle was the dylib's static entry dependency.
             for (const_name, byte_len, prefix) in &nextjs_path_inits {
                 let path_ptr = format!("@{}", const_name);
                 let len_str = byte_len.to_string();
@@ -655,6 +656,12 @@ pub(super) fn compile_module_entry(
                     ],
                 );
             }
+            for prefix in non_entry_module_prefixes {
+                if cross_module.deferred_module_prefixes.contains(prefix) {
+                    continue;
+                }
+                blk.call_void(&format!("{}__init", prefix), &[]);
+            }
         }
         // Mark the boundary between init prelude and user code so
         // hoisted post-init setup (cached `@perry_class_keys_*` loads
@@ -799,6 +806,7 @@ pub(super) fn compile_module_entry(
             imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
             method_param_counts: &cross_module.method_param_counts,
             method_has_rest: &cross_module.method_has_rest,
+            method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
             imported_func_return_types: &cross_module.imported_func_return_types,
             ffi_signatures: &cross_module.ffi_signatures,
             ffi_aliases: &cross_module.ffi_aliases,
@@ -1485,6 +1493,7 @@ pub(super) fn compile_module_entry(
             imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
             method_param_counts: &cross_module.method_param_counts,
             method_has_rest: &cross_module.method_has_rest,
+            method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
             imported_func_return_types: &cross_module.imported_func_return_types,
             ffi_signatures: &cross_module.ffi_signatures,
             ffi_aliases: &cross_module.ffi_aliases,

crates/perry-codegen/src/codegen/entry/tests.rs

@@ -1,5 +1,5 @@
 use crate::{compile_module, AppMetadata, CompileOptions};
-use perry_hir::{Module, ModuleInitKind};
+use perry_hir::{types::Type, Expr, Module, ModuleInitKind, Stmt};
 
 fn entry_opts(output_type: &str) -> CompileOptions {
     CompileOptions {
@@ -109,6 +109,18 @@ fn emitted_path_init_ir(output_type: &str) -> String {
         .expect("LLVM IR should be UTF-8")
 }
 
+fn nextjs_emitted_ir(output_type: &str) -> String {
+    let mut opts = entry_opts(output_type);
+    opts.non_entry_module_prefixes
+        .push("eager_route".to_string());
+    opts.nextjs_path_init_modules.push((
+        "/fixture/.next/server/chunks/300.js".to_string(),
+        "next_chunk_300".to_string(),
+    ));
+    String::from_utf8(compile_module(&empty_module(), opts).unwrap())
+        .expect("LLVM IR should be UTF-8")
+}
+
 #[test]
 fn executable_exit_releases_collection_side_allocations_last() {
     let ir = emitted_ir("executable");
@@ -212,3 +224,99 @@ fn module_init_body_runs_through_native_exception_boundary() {
         "the generated wrapper must not bypass the exception boundary\n{ir}"
     );
 }
+
+#[test]
+fn dylib_entry_registers_nextjs_runtime_paths() {
+    let ir = nextjs_emitted_ir("dylib");
+    assert!(
+        ir.contains("call void @js_globalthis_seed_async_local_storage()"),
+        "a Next dylib must seed AsyncLocalStorage before module init"
+    );
+    assert!(
+        ir.contains("call void @js_register_path_init("),
+        "a Next dylib must register deferred .next/server modules"
+    );
+    assert!(
+        ir.contains("ptrtoint (ptr @next_chunk_300__init to i64)"),
+        "the path registry must point at the generated chunk init"
+    );
+    let path_registration = ir
+        .find("call void @js_register_path_init(")
+        .expect("missing path registration");
+    let eager_init = ir
+        .find("call void @eager_route__init()")
+        .expect("missing eager module init");
+    assert!(
+        path_registration < eager_init,
+        "computed chunk requires can run during eager webpack module init"
+    );
+}
+
+#[test]
+fn unknown_function_fallback_is_module_scoped() {
+    let ir = emitted_ir("dylib");
+    assert!(
+        ir.contains("@__perry_wrap_perry_unknown_func_gc_exit_teardown_ts("),
+        "the fallback wrapper must be unique after codegen-unit promotion"
+    );
+    assert!(
+        !ir.contains("@__perry_wrap_perry_unknown_func("),
+        "the old process-global fallback collides across split modules"
+    );
+}
+
+#[test]
+fn dylib_closures_keep_native_roots() {
+    // #8081: the runtime rebuilds its stack-map index at module init and
+    // discovers compact GC maps in every loaded image, so a dlopen'ed app
+    // dylib keeps the same native-root lowering as an executable. Demoting
+    // dylibs to shadow frames would leave the provider gate exercising a
+    // lowering production never ships.
+    let _native = crate::codegen::helpers::NativeRootsPin::native();
+    let mut module = empty_module();
+    module.init.push(Stmt::Let {
+        id: 0,
+        name: "parse_query".to_string(),
+        ty: Type::Any,
+        mutable: false,
+        init: Some(Expr::Closure {
+            func_id: 1,
+            params: Vec::new(),
+            return_type: Type::Any,
+            body: vec![
+                Stmt::Let {
+                    id: 2,
+                    name: "result".to_string(),
+                    ty: Type::Array(Box::new(Type::Any)),
+                    mutable: true,
+                    init: Some(Expr::Array(Vec::new())),
+                },
+                Stmt::Return(Some(Expr::LocalGet(2))),
+            ],
+            captures: Vec::new(),
+            mutable_captures: Vec::new(),
+            captures_this: false,
+            captures_new_target: false,
+            enclosing_class: None,
+            is_arrow: true,
+            is_async: false,
+            is_generator: false,
+            is_strict: true,
+        }),
+    });
+
+    let ir = String::from_utf8(compile_module(&module, entry_opts("dylib")).unwrap())
+        .expect("LLVM IR should be UTF-8");
+    let closure = ir
+        .split("define ")
+        .find(|body| body.starts_with("double @perry_closure_") && body.contains("__1("))
+        .unwrap_or_else(|| panic!("missing closure body in dylib IR:\n{ir}"));
+    assert!(
+        closure.contains("gc \"statepoint-example\""),
+        "dylib closure must keep the native statepoint lowering:\n{closure}"
+    );
+    assert!(
+        !closure.contains("call ptr @js_shadow_frame_enter(i32 "),
+        "dylib roots must not be demoted to the shadow stack:\n{closure}"
+    );
+}

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

@@ -964,6 +964,7 @@ pub(super) fn compile_function(
         imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
         method_param_counts: &cross_module.method_param_counts,
         method_has_rest: &cross_module.method_has_rest,
+        method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
         imported_func_return_types: &cross_module.imported_func_return_types,
         ffi_signatures: &cross_module.ffi_signatures,
         ffi_aliases: &cross_module.ffi_aliases,

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

@@ -497,6 +497,7 @@ pub(super) fn compile_method(
         imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
         method_param_counts: &cross_module.method_param_counts,
         method_has_rest: &cross_module.method_has_rest,
+        method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
         imported_func_return_types: &cross_module.imported_func_return_types,
         ffi_signatures: &cross_module.ffi_signatures,
         ffi_aliases: &cross_module.ffi_aliases,
@@ -1566,6 +1567,7 @@ pub(super) fn compile_static_method(
         imported_func_synthetic_arguments: &cross_module.imported_func_synthetic_arguments,
         method_param_counts: &cross_module.method_param_counts,
         method_has_rest: &cross_module.method_has_rest,
+        method_has_synthetic_arguments: &cross_module.method_has_synthetic_arguments,
         imported_func_return_types: &cross_module.imported_func_return_types,
         ffi_signatures: &cross_module.ffi_signatures,
         ffi_aliases: &cross_module.ffi_aliases,

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

@@ -1374,12 +1374,21 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
     // already had `func_signatures.has_rest`.
     let mut method_has_rest: std::collections::HashMap<(String, String), bool> =
         std::collections::HashMap::new();
+    let mut method_has_synthetic_arguments: std::collections::HashMap<(String, String), bool> =
+        std::collections::HashMap::new();
     for cls in &hir.classes {
         for m in &cls.methods {
-            method_param_counts.insert((cls.name.clone(), m.name.clone()), m.params.len());
+            let key = (cls.name.clone(), m.name.clone());
+            method_param_counts.insert(key.clone(), m.params.len());
             let has_rest = m.params.iter().any(|p| p.is_rest);
             if has_rest {
-                method_has_rest.insert((cls.name.clone(), m.name.clone()), true);
+                method_has_rest.insert(key.clone(), true);
+            }
+            if m.params
+                .last()
+                .is_some_and(|param| param.arguments_object.is_some())
+            {
+                method_has_synthetic_arguments.insert(key, true);
             }
         }
         // Issue #894: track static methods too. Effect's `static pipe()` /
@@ -1395,7 +1404,14 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
             method_param_counts.insert((cls.name.clone(), key.clone()), sm.params.len());
             let has_rest = sm.params.iter().any(|p| p.is_rest);
             if has_rest {
-                method_has_rest.insert((cls.name.clone(), key), true);
+                method_has_rest.insert((cls.name.clone(), key.clone()), true);
+            }
+            if sm
+                .params
+                .last()
+                .is_some_and(|param| param.arguments_object.is_some())
+            {
+                method_has_synthetic_arguments.insert((cls.name.clone(), key), true);
             }
         }
     }
@@ -1421,6 +1437,18 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
                     method_has_rest.insert((effective_name.clone(), mname.clone()), true);
                 }
             }
+            if ic
+                .method_has_synthetic_arguments
+                .get(i)
+                .copied()
+                .unwrap_or(false)
+            {
+                method_has_synthetic_arguments.insert((ic.name.clone(), mname.clone()), true);
+                if effective_name != ic.name {
+                    method_has_synthetic_arguments
+                        .insert((effective_name.clone(), mname.clone()), true);
+                }
+            }
         }
     }
 
@@ -1816,6 +1844,7 @@ pub fn compile_module(hir: &HirModule, opts: CompileOptions) -> Result<Vec<u8>>
         func_returns_class: func_returns_class_map,
         method_param_counts,
         method_has_rest,
+        method_has_synthetic_arguments,
         class_keys_globals: class_keys_globals_map,
         class_field_counts: class_field_counts_map,
         class_init_chains: class_init_chains_map,

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

@@ -519,6 +519,11 @@ pub struct ImportedClass {
     /// fix for the freestanding-function path. Empty Vec means "fall through
     /// to the old behavior (no rest)".
     pub method_has_rest: Vec<bool>,
+    /// Parallel to `method_names`. `true` identifies the rest-shaped trailing
+    /// slot that Perry synthesized for a source method which reads
+    /// `arguments`. Unlike a user `...rest` slot, this slot receives every
+    /// actual argument while the named parameters remain positional.
+    pub method_has_synthetic_arguments: Vec<bool>,
     /// Static field names defined on this class. Used to declare the foreign
     /// `@perry_static_<src>__<class>__<field>` global with external linkage
     /// so cross-module `[Parent.Symbol.X] = …` reads/writes resolve to the
@@ -697,6 +702,11 @@ pub(crate) struct CrossModuleCtx {
     /// rest-bundling in `lower_call.rs`'s static / dynamic dispatch
     /// arms. Closes #484. Sparse map (only `true` entries stored).
     pub method_has_rest: std::collections::HashMap<(String, String), bool>,
+    /// Per-`(class, method)` synthesized-`arguments` flag. This is a subset of
+    /// `method_has_rest`, but the call-site packing semantics differ: the
+    /// synthetic slot receives all actual arguments rather than only the
+    /// values after the visible parameters.
+    pub method_has_synthetic_arguments: std::collections::HashMap<(String, String), bool>,
     /// Per-class `keys_array` global variable names. Each entry maps
     /// `class_name → @perry_class_keys_<modprefix>__<sanitized_class>`.
     /// Built once in `compile_module` (one entry per class — local

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

@@ -635,6 +635,10 @@ pub(crate) struct FnCtx<'a> {
     /// of undefined". Same shape as `func_signatures`'s `has_rest`
     /// bit but for class-method dispatch.
     pub method_has_rest: &'a std::collections::HashMap<(String, String), bool>,
+    /// Subset of `method_has_rest` whose trailing rest-shaped slot is the
+    /// compiler-synthesized `arguments` binding and therefore receives every
+    /// actual argument.
+    pub method_has_synthetic_arguments: &'a std::collections::HashMap<(String, String), bool>,
     /// FFI manifest: `name -> (params, return)` from `package.json`
     /// `nativeLibrary.functions`. Descriptors use the shared native-library
     /// ABI vocabulary. `lower_call` consults