fix(windows): scanned WinUI callback keys; complete Node async_hooks lifecycle parity (#8797)

Lands #8764 and #8671.

#8764 keeps WinUI callbacks behind scanned keys, addressing #8734: the
callback pointers that were copied out of the GC-scanned tables into
Reactor element-tree closures, where no scanner could reach or rewrite
them. This is the Windows-side fix, authored on a Windows host.

#8671 completes Node async_hooks lifecycle parity.

Both were showing pr-gate red before #8791 landed, because main itself
was failing `cargo-test` on a Web Streams test.

No version bump.

Co-authored-by: Ralph Küpper <ralph@skelpo.com>

Author: proggeramlug

changelog.d/8671-async-hooks-parity.md

@@ -0,0 +1,8 @@
+### Fixed
+
+- Complete the `node:async_hooks` parity tracker across all 194 fixtures:
+  hook mutation and lifecycle ordering, Promise/resource identity and trigger
+  chains, `AsyncResource` and `EventEmitterAsyncResource` subclasses,
+  `AsyncLocalStorage` propagation, and provider lifecycles for timers, files,
+  DNS, crypto, zlib, processes, signals, workers, streams, net, HTTP(S), TLS,
+  readline, event iterators, ESM, fetch, and UDP now match Node.

changelog.d/8734-winui-callback-indirection.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed WinUI widget, application-exit, and timer callbacks becoming stale after an evacuating garbage collection. Windows Reactor closures now retain stable widget/slot keys and resolve callbacks from GC-scanned storage immediately before invocation; timer callbacks likewise remain in a scanned key-indexed table instead of being copied into opaque `DispatcherTimer` closures.

crates/perry-api-manifest/src/entries/part_4.rs

@@ -838,6 +838,7 @@ pub(crate) const API_MANIFEST_PART_4: &[ApiEntry] = &[
     method("http", "ref", true, Some("HttpServer")),
     method("http", "unref", true, Some("HttpServer")),
     method("http", "on", true, Some("IncomingMessage")),
+    method("http", "once", true, Some("IncomingMessage")),
     method("http", "addListener", true, Some("IncomingMessage")),
     method("http", "pause", true, Some("IncomingMessage")),
     method("http", "resume", true, Some("IncomingMessage")),
@@ -856,6 +857,7 @@ pub(crate) const API_MANIFEST_PART_4: &[ApiEntry] = &[
     // method, so the manifest-consistency drift guard requires a row
     // here even though the test collapses class_filter variants.
     method("http", "setTimeout", true, Some("ClientRequest")),
+    method("http", "once", true, Some("ClientRequest")),
     method("http", "listenerCount", true, Some("ClientRequest")),
     method("http", "setHeader", true, Some("ClientRequest")),
     method("http", "getHeader", true, Some("ClientRequest")),

crates/perry-codegen/src/expr/calls/crypto_misc.rs

@@ -271,13 +271,18 @@ pub(crate) fn arm_crypto_prime(
         unreachable!()
     };
     let first_box = lower_expr(ctx, &args[0])?;
-    let options_box = if args.len() >= 2 {
+    let is_async = matches!(property, "generatePrime" | "checkPrime");
+    // The callback forms are `(value, callback)` or
+    // `(value, options, callback)`.  Treating the second argument as options
+    // unconditionally accidentally routed the common two-argument form to
+    // the synchronous implementation and returned the generated value.
+    let options_box = if args.len() >= 2 && (!is_async || args.len() >= 3) {
         lower_expr(ctx, &args[1])?
     } else {
         double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED))
     };
-    let callback_box = if matches!(property, "generatePrime" | "checkPrime") && args.len() >= 3 {
-        Some(lower_expr(ctx, &args[2])?)
+    let callback_box = if is_async && args.len() >= 2 {
+        Some(lower_expr(ctx, &args[args.len().min(3) - 1])?)
     } else {
         None
     };

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

@@ -193,7 +193,7 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
             let blk = ctx.block();
             let raw = blk.call(
                 I64,
-                "js_net_create_server",
+                "js_ext_net_create_server",
                 &[(I64, &options_i64), (I64, &listener_i64)],
             );
             Ok(nanbox_pointer_inline(blk, &raw))

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

@@ -483,6 +483,8 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                 // Promise values are raw promise allocations, not ObjectHeader
                 // instances with a class_id field.
                 "Promise" => 0xFFFF0027u32,
+                "AsyncLocalStorage" => 0xFFFF0078u32,
+                "AsyncResource" => 0xFFFF0079u32,
                 // WHATWG fetch types. Like Blob/streams these are pointer-tagged
                 // small-int handles; the runtime resolves them via the stdlib
                 // fetch kind-probe (`res instanceof Response`, etc.).

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

@@ -132,7 +132,8 @@ pub(crate) use write_barrier::{
     emit_root_heap_word_store_on_block, emit_root_nanbox_store_on_block, emit_write_barrier,
     emit_write_barrier_slot_generation_tested, emit_write_barrier_slot_on_block,
     emit_write_barrier_slot_value_and_generation_tested, lower_array_super_init,
-    lower_event_emitter_subclass_init, lower_node_stream_super_init, lower_stream_super_init,
+    lower_event_emitter_async_resource_subclass_init, lower_event_emitter_subclass_init,
+    lower_node_stream_super_init, lower_stream_super_init,
 };
 
 // Issue #1098 phase 3: the `FnCtx` definition stays in this trunk, but its

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

@@ -1376,6 +1376,15 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                 if receiver_class_is_proven && is_net_native_method_value(&class_name, property) {
                     return lower_class_method_bind(ctx, object, property);
                 }
+                if receiver_class_is_proven
+                    && class_name == "AsyncResource"
+                    && matches!(
+                        property.as_str(),
+                        "asyncId" | "triggerAsyncId" | "emitDestroy" | "runInAsyncScope" | "bind"
+                    )
+                {
+                    return lower_runtime_property_get_by_name(ctx, object, property);
+                }
                 if class_has_computed_runtime_members(ctx, &class_name) {
                     return lower_runtime_property_get_by_name(ctx, object, property);
                 }

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

@@ -12,8 +12,9 @@ use crate::nanbox::{double_literal, POINTER_MASK_I64};
 use crate::types::{DOUBLE, I1, I32, I64, PTR};
 
 use super::{
-    lower_array_super_init, lower_event_emitter_subclass_init, lower_expr,
-    lower_node_stream_super_init, lower_stream_super_init, nanbox_pointer_inline, FnCtx,
+    lower_array_super_init, lower_event_emitter_async_resource_subclass_init,
+    lower_event_emitter_subclass_init, lower_expr, lower_node_stream_super_init,
+    lower_stream_super_init, nanbox_pointer_inline, FnCtx,
 };
 
 /// Enter one derived constructor's `super()` binding scope.
@@ -826,6 +827,83 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                         )?;
                         return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
                     }
+                    if parent_name.as_str() == "EventEmitterAsyncResource" {
+                        let mut lowered = Vec::with_capacity(super_args.len());
+                        for arg in super_args {
+                            lowered.push(lower_expr(ctx, arg)?);
+                        }
+                        let options = lowered.first().cloned().unwrap_or_else(|| {
+                            double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED))
+                        });
+                        let this_box = match ctx.this_stack.last().cloned() {
+                            Some(slot) => ctx.block().load(DOUBLE, &slot),
+                            None => double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)),
+                        };
+                        lower_event_emitter_async_resource_subclass_init(ctx, &this_box, &options);
+                        bind_derived_this_after_super(ctx);
+                        let current_class_name =
+                            ctx.class_stack.last().cloned().unwrap_or_default();
+                        crate::lower_call::apply_field_initializers_recursive(
+                            ctx,
+                            &current_class_name,
+                            crate::lower_call::FieldInitMode::SelfOnly,
+                        )?;
+                        return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+                    }
+                    if parent_name.as_str() == "AsyncLocalStorage" {
+                        for arg in super_args {
+                            let _ = lower_expr(ctx, arg)?;
+                        }
+                        let this_box = match ctx.this_stack.last().cloned() {
+                            Some(slot) => ctx.block().load(DOUBLE, &slot),
+                            None => double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)),
+                        };
+                        ctx.block().call(
+                            DOUBLE,
+                            "js_async_local_storage_subclass_init",
+                            &[(DOUBLE, &this_box)],
+                        );
+                        bind_derived_this_after_super(ctx);
+                        let current_class_name =
+                            ctx.class_stack.last().cloned().unwrap_or_default();
+                        crate::lower_call::apply_field_initializers_recursive(
+                            ctx,
+                            &current_class_name,
+                            crate::lower_call::FieldInitMode::SelfOnly,
+                        )?;
+                        return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+                    }
+                    if parent_name.as_str() == "AsyncResource" {
+                        let undef = double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED));
+                        let mut lowered = Vec::with_capacity(super_args.len());
+                        for arg in super_args {
+                            lowered.push(lower_expr(ctx, arg)?);
+                        }
+                        let type_value = lowered.first().cloned().unwrap_or_else(|| undef.clone());
+                        let options = lowered.get(1).cloned().unwrap_or_else(|| undef.clone());
+                        let this_box = match ctx.this_stack.last().cloned() {
+                            Some(slot) => ctx.block().load(DOUBLE, &slot),
+                            None => undef,
+                        };
+                        ctx.block().call(
+                            DOUBLE,
+                            "js_async_resource_subclass_init",
+                            &[
+                                (DOUBLE, &this_box),
+                                (DOUBLE, &type_value),
+                                (DOUBLE, &options),
+                            ],
+                        );
+                        bind_derived_this_after_super(ctx);
+                        let current_class_name =
+                            ctx.class_stack.last().cloned().unwrap_or_default();
+                        crate::lower_call::apply_field_initializers_recursive(
+                            ctx,
+                            &current_class_name,
+                            crate::lower_call::FieldInitMode::SelfOnly,
+                        )?;
+                        return Ok(double_literal(f64::from_bits(crate::nanbox::TAG_UNDEFINED)));
+                    }
                     // `class X extends Request` / `extends Response`:
                     // `super(input, init)` allocates the underlying native
                     // Web-Fetch handle and stashes its id on `this` under

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

@@ -1081,3 +1081,15 @@ pub(crate) fn lower_event_emitter_subclass_init(ctx: &mut FnCtx<'_>, this_box: &
         &[(DOUBLE, this_box)],
     );
 }
+
+pub(crate) fn lower_event_emitter_async_resource_subclass_init(
+    ctx: &mut FnCtx<'_>,
+    this_box: &str,
+    options_box: &str,
+) {
+    ctx.block().call(
+        DOUBLE,
+        "js_event_emitter_async_resource_subclass_init",
+        &[(DOUBLE, this_box), (DOUBLE, options_box)],
+    );
+}