fix(async_hooks): complete node suite parity

changelog.d/6764-async-hooks-final.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Locked `node:async_hooks` parity at 195/195 fixtures, including strict frozen provider-table writes and portable lifecycle/provider checks across Windows and Unix.

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

@@ -56,6 +56,15 @@ fn compile_body(name: &str, body: Vec<Stmt>) -> String {
 }
 
 fn compile_body_with_params(name: &str, params: Vec<Param>, body: Vec<Stmt>) -> String {
+    compile_body_with_params_and_strict(name, params, body, true)
+}
+
+fn compile_body_with_params_and_strict(
+    name: &str,
+    params: Vec<Param>,
+    body: Vec<Stmt>,
+    is_strict: bool,
+) -> String {
     let mut hir = HirModule::new(name);
     hir.functions.push(Function {
         id: 0,
@@ -66,7 +75,7 @@ fn compile_body_with_params(name: &str, params: Vec<Param>, body: Vec<Stmt>) ->
         body,
         is_async: false,
         is_generator: false,
-        is_strict: true,
+        is_strict,
         is_exported: false,
         captures: Vec::new(),
         decorators: Vec::new(),
@@ -445,25 +454,30 @@ fn erased_receiver_inline_store_roots_receiver_and_key_across_rhs() {
     };
     let collecting = compile("erased_store_collecting", allocating_value());
     let inert = compile("erased_store_inert", inert_value());
-    let callee = "@js_dyn_index_set(";
+    let callee = "@js_dyn_index_set_strict(";
     assert!(
         collecting.contains(callee) && inert.contains(callee),
         "both fixtures must reach the #5525 inline dynamic-store arm:\n{collecting}\n{inert}"
     );
     assert_call_operand_rooted_across_operand(
         &collecting,
-        "js_dyn_index_set",
+        "js_dyn_index_set_strict",
         0,
         2,
         "the erased receiver",
     );
     assert_call_operand_rooted_across_operand(
         &collecting,
-        "js_dyn_index_set",
+        "js_dyn_index_set_strict",
         1,
         2,
         "the erased property key",
     );
+    assert_eq!(
+        call_operand_of(&collecting, "js_dyn_index_set_strict", 3),
+        "1",
+        "ES module computed stores must preserve strict assignment semantics"
+    );
     assert_eq!(
         root_slots(&collecting),
         root_slots(&inert) + 2,
@@ -472,6 +486,34 @@ fn erased_receiver_inline_store_roots_receiver_and_key_across_rhs() {
     );
 }
 
+/// A source-text module is strict, but its top-level statements are emitted in
+/// a synthetic module-init function that is not itself marked strict. When a
+/// strict `PutValueSet` takes the untyped index-store optimization, preserve
+/// the reference's flag rather than substituting the container function's.
+#[test]
+fn put_value_index_fast_path_preserves_explicit_module_strictness() {
+    let _native_roots = crate::codegen::helpers::NativeRootsPin::native();
+    let receiver = Expr::LocalGet(1);
+    let ir = compile_body_with_params_and_strict(
+        "strict_put_value_index_fast_path",
+        vec![param(1, "receiver", Type::Any), param(2, "key", Type::Any)],
+        vec![Stmt::Expr(Expr::PutValueSet {
+            target: Box::new(receiver.clone()),
+            key: Box::new(Expr::LocalGet(2)),
+            value: Box::new(Expr::Integer(1)),
+            receiver: Box::new(receiver),
+            strict: true,
+        })],
+        false,
+    );
+
+    assert_eq!(
+        call_operand_of(&ir, "js_dyn_index_set_strict", 3),
+        "1",
+        "the strict PutValue reference must survive a non-strict module-init container"
+    );
+}
+
 /// #7640 E follow-up — a cached `BufferViewSlot::data_slot` is safe across a
 /// collecting operand only when the construction proves fresh inline storage.
 /// View-backed reads/writes must decline before evaluating either operand and

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

@@ -60,7 +60,10 @@ pub(crate) fn lower_expr(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
             super::objects_arrays_lit::lower(ctx, expr)
         }
         Expr::IndexGet { .. } => super::index_get::lower(ctx, expr),
-        Expr::IndexSet { .. } => super::index_set::lower(ctx, expr, value_discarded),
+        Expr::IndexSet { .. } => {
+            let strict = ctx.is_strict_fn;
+            super::index_set::lower(ctx, expr, value_discarded, strict)
+        }
         Expr::PropertySet { .. } => super::property_set::lower(ctx, expr),
         Expr::PropertyGet { .. } => super::property_get::lower(ctx, expr),
         Expr::Conditional { .. } => super::conditional::lower(ctx, expr),

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

@@ -355,16 +355,23 @@ pub(crate) fn lower(
     expr: &Expr,
     // #7590: THIS expression's value is discarded (not merely the statement's).
     value_discarded: bool,
+    // `PutValueSet` may route a strict module-level reference through this
+    // fast path even though the synthetic module-init function is non-strict.
+    assignment_strict: bool,
 ) -> Result<String> {
     match expr {
         Expr::IndexSet {
             object,
             index,
             value,
         } => {
-            if let Some(result) =
-                super::typed_array_rmw::try_lower_guarded_uint32_add(ctx, object, index, value)?
-            {
+            if let Some(result) = super::typed_array_rmw::try_lower_guarded_uint32_add(
+                ctx,
+                object,
+                index,
+                value,
+                assignment_strict,
+            )? {
                 if value_discarded {
                     return Ok(double_literal(0.0));
                 }
@@ -612,6 +619,7 @@ pub(crate) fn lower(
                 Expr::String(_) | Expr::WtfString(_) | Expr::SymbolFor(_)
             ) || is_string_expr(ctx, index);
             if recv_unknown && !index_is_static_string_or_symbol {
+                let strict = assignment_strict;
                 return rooting::with_operands_rooted_across(
                     ctx,
                     &[object, index],
@@ -637,6 +645,7 @@ pub(crate) fn lower(
                             &vals[0],
                             &vals[1],
                             &val_double,
+                            strict,
                         ))
                     },
                 );

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

@@ -44,6 +44,7 @@ pub(super) fn lower_inline_dyn_typed_array_set(
     obj_box: &str,
     idx_d: &str,
     val_double: &str,
+    strict: bool,
 ) -> String {
     let tag_mask = crate::nanbox::i64_literal(crate::nanbox::TAG_MASK);
     let pointer_tag = crate::nanbox::POINTER_TAG_I64;
@@ -262,12 +263,18 @@ pub(super) fn lower_inline_dyn_typed_array_set(
         blk.br(&merge_label);
     }
 
-    // ---- slow: the unchanged runtime setter ----
+    // ---- slow: preserve the source function's assignment strictness ----
     ctx.current_block = slow_idx;
+    let strict = if strict { "1" } else { "0" };
     ctx.block().call(
         DOUBLE,
-        "js_dyn_index_set",
-        &[(DOUBLE, obj_box), (DOUBLE, idx_d), (DOUBLE, val_double)],
+        "js_dyn_index_set_strict",
+        &[
+            (DOUBLE, obj_box),
+            (DOUBLE, idx_d),
+            (DOUBLE, val_double),
+            (I32, strict),
+        ],
     );
     ctx.block().br(&merge_label);
 

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

@@ -1586,6 +1586,10 @@ pub(crate) fn lower(ctx: &mut FnCtx<'_>, expr: &Expr) -> Result<String> {
                     // path returns the assigned value to ITS caller, which may
                     // well consume it. Never the discarded form.
                     false,
+                    // Preserve the reference's own strictness. Module init is
+                    // a synthetic non-strict function even though module code
+                    // carries strict PutValue references.
+                    *strict,
                 );
             }
             if let Some(result) =

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

@@ -209,15 +209,22 @@ fn emit_generic_set(
     object: &Expr,
     index: &Expr,
     value: &str,
+    assignment_strict: bool,
 ) -> Result<String> {
     // Re-read the immutable reference temporaries after any allocating RHS;
     // their slots are the GC-visible source of truth.
     let object_box = lower_expr(ctx, object)?;
     let index_box = lower_expr(ctx, index)?;
+    let strict = if assignment_strict { "1" } else { "0" };
     Ok(ctx.block().call(
         DOUBLE,
-        "js_dyn_index_set",
-        &[(DOUBLE, &object_box), (DOUBLE, &index_box), (DOUBLE, value)],
+        "js_dyn_index_set_strict",
+        &[
+            (DOUBLE, &object_box),
+            (DOUBLE, &index_box),
+            (DOUBLE, value),
+            (I32, strict),
+        ],
     ))
 }
 
@@ -230,6 +237,7 @@ pub(super) fn try_lower_guarded_uint32_add(
     object: &Expr,
     index: &Expr,
     value: &Expr,
+    assignment_strict: bool,
 ) -> Result<Option<String>> {
     if !enabled() {
         return Ok(None);
@@ -334,7 +342,13 @@ pub(super) fn try_lower_guarded_uint32_add(
     let store_end = ctx.block().label.clone();
 
     ctx.current_block = set_fallback_idx;
-    let set_fallback_value = emit_generic_set(ctx, candidate.object, candidate.index, &sum)?;
+    let set_fallback_value = emit_generic_set(
+        ctx,
+        candidate.object,
+        candidate.index,
+        &sum,
+        assignment_strict,
+    )?;
     ctx.block().br(&merge_label);
     let set_fallback_end = ctx.block().label.clone();
 
@@ -344,8 +358,13 @@ pub(super) fn try_lower_guarded_uint32_add(
     // stores, and every abrupt-completion case.
     ctx.current_block = full_fallback_idx;
     let generic_sum = lower_expr(ctx, value)?;
-    let full_fallback_value =
-        emit_generic_set(ctx, candidate.object, candidate.index, &generic_sum)?;
+    let full_fallback_value = emit_generic_set(
+        ctx,
+        candidate.object,
+        candidate.index,
+        &generic_sum,
+        assignment_strict,
+    )?;
     ctx.block().br(&merge_label);
     let full_fallback_end = ctx.block().label.clone();
 

crates/perry-codegen/src/runtime_decls/strings.rs

@@ -736,6 +736,11 @@ pub fn declare_phase_b_strings(module: &mut LlModule) {
     // IndexSet dispatch tree. Routes to `js_array_set_index_or_string` for
     // arrays and `js_object_set_field_by_name` for plain objects.
     module.declare_function("js_dyn_index_set", DOUBLE, &[DOUBLE, DOUBLE, DOUBLE]);
+    module.declare_function(
+        "js_dyn_index_set_strict",
+        DOUBLE,
+        &[DOUBLE, DOUBLE, DOUBLE, I32],
+    );
     module.declare_function("js_string_to_char_array", I64, &[I64]);
     module.declare_function("js_string_repeat", I64, &[I64, DOUBLE]);
     module.declare_function("js_string_replace_string", I64, &[I64, I64, I64]);

crates/perry-runtime/src/value/dyn_index.rs

@@ -524,9 +524,9 @@ pub extern "C" fn js_dyn_index_get(value: f64, index: f64) -> f64 {
     v
 }
 
-/// Issue #957 — tag-aware dynamic index write counterpart to
-/// `js_dyn_index_get`. Used by `Expr::IndexUpdate` codegen to write back
-/// the incremented value without duplicating the IndexSet dispatch tree.
+/// Issue #957 — sloppy-assignment-compatible dynamic index write counterpart
+/// to `js_dyn_index_get`. Runtime callers retain this entry point; generated
+/// computed assignments use [`js_dyn_index_set_strict`] below.
 ///
 /// Routes by the receiver's `gc_type` byte: arrays go through
 /// `js_array_set_index_or_string_strict` (numeric/string-key spec dispatch);
@@ -536,6 +536,14 @@ pub extern "C" fn js_dyn_index_get(value: f64, index: f64) -> f64 {
 /// pattern this is added for).
 #[no_mangle]
 pub extern "C" fn js_dyn_index_set(obj: f64, index: f64, value: f64) -> f64 {
+    js_dyn_index_set_strict(obj, index, value, 0)
+}
+
+/// Strictness-aware entry point for generated computed assignments. Keep the
+/// three-argument export above for runtime callers that intentionally retain
+/// the historical sloppy-assignment behavior.
+#[no_mangle]
+pub extern "C" fn js_dyn_index_set_strict(obj: f64, index: f64, value: f64, strict: i32) -> f64 {
     let bits = obj.to_bits();
     let jsval = JSValue::from_bits(bits);
     // Proxies use small tagged handles rather than heap addresses. They must
@@ -552,7 +560,12 @@ pub extern "C" fn js_dyn_index_set(obj: f64, index: f64, value: f64) -> f64 {
         let index = scope.root_nanbox_f64(index);
         let value = scope.root_nanbox_f64(value);
         let boxed = crate::builtins::js_boxed_symbol_new(symbol.get_nanbox_f64());
-        return js_dyn_index_set(boxed, index.get_nanbox_f64(), value.get_nanbox_f64());
+        return js_dyn_index_set_strict(
+            boxed,
+            index.get_nanbox_f64(),
+            value.get_nanbox_f64(),
+            strict,
+        );
     }
     // #5525: a Symbol *index* (`obj[sym] = v`) routes to the symbol side-table,
     // mirroring the get side. Codegen sends all non-string-literal unknown-
@@ -655,7 +668,7 @@ pub extern "C" fn js_dyn_index_set(obj: f64, index: f64, value: f64) -> f64 {
         } else {
             f64::from_bits(crate::value::js_nanbox_pointer(raw_ptr as i64).to_bits())
         };
-        return crate::proxy::js_put_value_set(target, index, value, target, 0);
+        return crate::proxy::js_put_value_set(target, index, value, target, strict);
     }
     if crate::typedarray::lookup_typed_array_kind(raw_ptr).is_some() {
         crate::typedarray_props::js_typed_array_index_set_dynamic(
@@ -718,7 +731,7 @@ pub extern "C" fn js_dyn_index_set(obj: f64, index: f64, value: f64) -> f64 {
                 } else {
                     f64::from_bits(crate::value::js_nanbox_pointer(raw_ptr as i64).to_bits())
                 };
-                return crate::proxy::js_put_value_set(target, index, value, target, 0);
+                return crate::proxy::js_put_value_set(target, index, value, target, strict);
             }
         }
     }
@@ -843,7 +856,8 @@ pub extern "C" fn js_is_undefined_or_bare_nan(value: f64) -> i32 {
 
 // --- #1561: force-keep the dynamic-index FFI exports under LTO ---
 //
-// `js_dyn_index_get` / `js_dyn_index_set` / `js_is_undefined_or_bare_nan`
+// `js_dyn_index_get` / `js_dyn_index_set` / `js_dyn_index_set_strict` /
+// `js_is_undefined_or_bare_nan`
 // are `#[no_mangle] pub extern "C"`, but they have **zero internal Rust
 // callers** — they are only ever invoked from generated LLVM IR (codegen
 // emits the calls in `perry-codegen/src/expr/index_get.rs` and
@@ -870,6 +884,10 @@ static KEEP_JS_DYN_INDEX_GET: extern "C" fn(f64, f64) -> f64 = js_dyn_index_get;
 static KEEP_JS_DYN_INDEX_SET: extern "C" fn(f64, f64, f64) -> f64 = js_dyn_index_set;
 #[cfg(feature = "keepalive-anchors")]
 #[used]
+static KEEP_JS_DYN_INDEX_SET_STRICT: extern "C" fn(f64, f64, f64, i32) -> f64 =
+    js_dyn_index_set_strict;
+#[cfg(feature = "keepalive-anchors")]
+#[used]
 static KEEP_JS_IS_UNDEFINED_OR_BARE_NAN: extern "C" fn(f64) -> i32 = js_is_undefined_or_bare_nan;
 
 #[cfg(test)]

crates/perry-runtime/src/value/mod.rs

@@ -111,7 +111,9 @@ pub use dynamic_arith::{
 };
 
 // ----- Dynamic index get/set + bare-NaN check -----
-pub use dyn_index::{js_dyn_index_get, js_dyn_index_set, js_is_undefined_or_bare_nan};
+pub use dyn_index::{
+    js_dyn_index_get, js_dyn_index_set, js_dyn_index_set_strict, js_is_undefined_or_bare_nan,
+};
 
 // ----- to-string conversion helpers -----
 pub(crate) use to_string::{