Implement $262.agent for test262 multi-agent Atomics tests

- Add js_agent.rs with agent thread spawning, broadcast, report queue, and receive primitives
- Register __agent_* native hooks in global env (mod.rs) and dispatch them in eval.rs
- Inject $262.agent shim in compose_test.js before harness files to avoid double $262 definition
- Change runner.js to detect and pass needsAgent flag instead of skipping agent tests
- Replace global ASYNC_WAITERS with thread-local PendingAsyncWaiterLocal for waitAsync promises
- Poll resolved async waiters in js_promise poll_event_loop for cross-thread promise resolution
- Keep event loop alive while pending async waiters exist (mod.rs event loop)
- Fix named function expression (NFE) self-binding by creating intermediate scope at closure creation
- Reset agent state per test for isolation, skip reset on agent threads

Author: ssrlive

ci/compose_test.js

@@ -280,7 +280,7 @@ function verifyComposeStubMarkerCount(testPath, harnessIndex = {}, prependFiles
   return count === expected;
 }
 
-function composeTest({testPath, repoDir, harnessIndex, prependFiles = [], needStrict = true}) {
+function composeTest({testPath, repoDir, harnessIndex, prependFiles = [], needStrict = true, needsAgent = false}) {
   // Returns { testToRun, tmpPath, cleanupTmp }
 
   // prepends are file paths
@@ -367,6 +367,25 @@ function composeTest({testPath, repoDir, harnessIndex, prependFiles = [], needSt
 
   // Write unique prepends
   PREPEND_FILES = ensureArrayDistinct(PREPEND_FILES);
+
+  // Inject $262.agent shim BEFORE harness files (atomicsHelper.js extends $262.agent)
+  if (needsAgent) {
+    outLines.push('// Inject: $262.agent shim for multi-agent tests');
+    outLines.push('if (typeof $262 === "undefined") { var $262 = {}; }');
+    outLines.push('if (!$262.agent) { $262.agent = {}; }');
+    outLines.push('$262.agent.start = function(script) { __agent_start(script); };');
+    outLines.push('$262.agent.broadcast = function(sab) {');
+    outLines.push('  if (sab && sab.buffer) { __agent_broadcast(sab.buffer); }');
+    outLines.push('  else { __agent_broadcast(sab); }');
+    outLines.push('};');
+    outLines.push('$262.agent.getReport = function() { return __agent_getReport(); };');
+    outLines.push('$262.agent.sleep = function(ms) { __agent_sleep(ms); };');
+    outLines.push('$262.agent.monotonicNow = function() { return __agent_monotonicNow(); };');
+    outLines.push('$262.agent.leaving = function() { __agent_leaving(); };');
+    outLines.push('$262.agent.report = function(val) { __agent_report(String(val)); };');
+    outLines.push('');
+  }
+
   for (const p of PREPEND_FILES) {
     if (!p) continue;
     if (fs.existsSync(p)) {
@@ -466,7 +485,7 @@ function composeTest({testPath, repoDir, harnessIndex, prependFiles = [], needSt
 
     // Inject unified $262 shim into the rebuilt file when required by test/meta
     const metaFixed = extractMeta(testPath);
-    inject262Shim(lines2, testPath, metaFixed);
+    inject262Shim(lines2, testPath, metaFixed, [], needsAgent);
 
     const absTest = path.resolve(testPath);
     lines2.push(`// Inject: ${absTest}`);

ci/runner.js

@@ -350,11 +350,9 @@ async function runAll(){
     if (/features:/.test(meta) && /Intl/.test(meta)) { skip++; log(`SKIP (feature: Intl) ${f}`); continue; }
     if (/\bIntl\b/.test(fs.readFileSync(f,'utf8'))) { skip++; log(`SKIP (contains Intl) ${f}`); continue; }
 
-    // Skip tests that require $262.agent (multi-threaded worker support)
-    {
-      const src = fs.readFileSync(f, 'utf8');
-      if (/\$262\.agent\b/.test(src)) { skip++; log(`SKIP ($262.agent) ${f}`); continue; }
-    }
+    // Detect tests that require $262.agent (multi-threaded worker support)
+    const _agentSrc = fs.readFileSync(f, 'utf8');
+    const needsAgent = /\$262\.agent\b/.test(_agentSrc);
 
     // handle includes
     const includes = parseIncludes(meta);
@@ -434,7 +432,7 @@ async function runAll(){
     // not inject a global "use strict" which can change eval semantics.
     const isModule = hasFlag(meta, 'module');
     const needStrict = !isModule && hasFlag(meta, 'onlyStrict');
-    const {testToRun, tmpPath, cleanupTmp} = composeTest({testPath: f, repoDir: REPO_DIR, harnessIndex:HARNESS_INDEX, prependFiles: resolved_includes, needStrict});
+    const {testToRun, tmpPath, cleanupTmp} = composeTest({testPath: f, repoDir: REPO_DIR, harnessIndex:HARNESS_INDEX, prependFiles: resolved_includes, needStrict, needsAgent});
 
     let currentSucceeds = false;
     // Run test

src/core/eval.rs

@@ -19020,10 +19020,29 @@ fn evaluate_function_expression<'gc>(
 
     let is_strict = has_body_use_strict || env_strict_ancestor;
 
+    // For Named Function Expressions (NFE), create an intermediate scope that
+    // contains the self-binding so the function can reference itself by name
+    // even when invoked indirectly (e.g., via setTimeout). Per the ES spec,
+    // the NFE name is bound in a scope between the outer env and the closure's
+    // own parameter scope.
+    let closure_env = if let Some(ref n) = name {
+        if !n.is_empty() {
+            let nfe_env = crate::core::new_js_object_data(mc);
+            nfe_env.borrow_mut(mc).prototype = Some(*env);
+            nfe_env.borrow_mut(mc).is_function_scope = false;
+            // The binding will be set to the function object after it's created (below).
+            nfe_env
+        } else {
+            *env
+        }
+    } else {
+        *env
+    };
+
     let closure_data = ClosureData {
         params: params.to_vec(),
         body: body.to_vec(),
-        env: Some(*env),
+        env: Some(closure_env),
         is_strict,
         enforce_strictness_inheritance: true,
         ..ClosureData::default()
@@ -19032,6 +19051,12 @@ fn evaluate_function_expression<'gc>(
     func_obj.borrow_mut(mc).set_closure(Some(new_gc_cell_ptr(mc, closure_val)));
     match name {
         Some(n) if !n.is_empty() => {
+            // Set the NFE self-binding in the intermediate scope so the function
+            // can reference itself by name from any invocation path.
+            object_set_key_value(mc, &closure_env, &n, &Value::Object(func_obj))?;
+            if is_strict {
+                closure_env.borrow_mut(mc).set_non_writable(&n);
+            }
             let desc = create_descriptor_object(mc, &Value::String(utf8_to_utf16(&n)), false, false, true)?;
             crate::js_object::define_property_internal(mc, &func_obj, "name", &desc)?;
         }
@@ -20113,6 +20138,92 @@ pub fn call_native_function<'gc>(
         return Err(raise_type_error!("detachArrayBuffer requires an ArrayBuffer object").into());
     }
 
+    // ─── $262.agent native hooks ───────────────────────────────────────────
+    if name == "__agent_start" {
+        let script = match args.first() {
+            Some(Value::String(s)) => crate::unicode::utf16_to_utf8(s),
+            Some(v) => crate::core::value_to_string(v),
+            None => String::new(),
+        };
+        crate::js_agent::agent_start(script);
+        return Ok(Some(Value::Undefined));
+    }
+    if name == "__agent_broadcast" {
+        // Accepts a SharedArrayBuffer object; extract its Arc data
+        if let Some(Value::Object(obj)) = args.first()
+            && let Some(ab_val) = slot_get_chained(obj, &InternalSlot::ArrayBuffer)
+            && let Value::ArrayBuffer(ab) = &*ab_val.borrow()
+        {
+            let ab_ref = ab.borrow();
+            if !ab_ref.shared {
+                return Err(raise_type_error!("agent.broadcast requires a SharedArrayBuffer").into());
+            }
+            let data_arc = ab_ref.data.clone();
+            let byte_length = ab_ref.data.lock().unwrap().len();
+            crate::js_agent::agent_broadcast(data_arc, byte_length);
+            return Ok(Some(Value::Undefined));
+        }
+        return Err(raise_type_error!("agent.broadcast requires a SharedArrayBuffer").into());
+    }
+    if name == "__agent_getReport" {
+        return Ok(Some(match crate::js_agent::agent_get_report() {
+            Some(s) => Value::String(crate::unicode::utf8_to_utf16(&s)),
+            None => Value::Null,
+        }));
+    }
+    if name == "__agent_sleep" {
+        let ms = match args.first() {
+            Some(v) => crate::core::to_number_with_env(mc, env, v)?,
+            None => 0.0,
+        };
+        crate::js_agent::agent_sleep(ms);
+        return Ok(Some(Value::Undefined));
+    }
+    if name == "__agent_monotonicNow" {
+        return Ok(Some(Value::Number(crate::js_agent::agent_monotonic_now())));
+    }
+    if name == "__agent_receiveBroadcast" {
+        // Called from within an agent thread. Blocks until broadcast is available.
+        // Returns a SharedArrayBuffer object wrapping the same Arc data.
+        let (data_arc, byte_length) = crate::js_agent::agent_receive_broadcast();
+        let obj = crate::core::new_js_object_data(mc);
+        // Set up SharedArrayBuffer prototype
+        if let Some(ctor_val) = crate::core::env_get(env, "SharedArrayBuffer")
+            && let Value::Object(ctor_obj) = &*ctor_val.borrow()
+            && let Some(p_val) = object_get_key_value(ctor_obj, "prototype")
+            && let Value::Object(p_obj) = &*p_val.borrow()
+        {
+            obj.borrow_mut(mc).prototype = Some(*p_obj);
+        }
+        let buffer = new_gc_cell_ptr(
+            mc,
+            crate::core::value::JSArrayBuffer {
+                data: data_arc,
+                shared: true,
+                detached: false,
+                max_byte_length: None,
+                immutable: false,
+            },
+        );
+        slot_set(mc, &obj, InternalSlot::ArrayBuffer, &Value::ArrayBuffer(buffer));
+        // Store byte_length for byteLength getter
+        let _ = byte_length; // byte_length is already encoded in the Arc Vec
+        return Ok(Some(Value::Object(obj)));
+    }
+    if name == "__agent_report" {
+        let val = match args.first() {
+            Some(Value::String(s)) => crate::unicode::utf16_to_utf8(s),
+            Some(v) => crate::core::value_to_string(v),
+            None => String::new(),
+        };
+        crate::js_agent::agent_report(val);
+        return Ok(Some(Value::Undefined));
+    }
+    if name == "__agent_leaving" {
+        crate::js_agent::agent_leaving();
+        return Ok(Some(Value::Undefined));
+    }
+
     if name == "Array.isArray" || name == "Array.from" || name == "Array.of" || name == "Array.fromAsync" {
         let method = name.trim_start_matches("Array.");
         let v = crate::js_array::handle_array_static_method(mc, method, this_val, args, env)?;

src/core/mod.rs

@@ -360,6 +360,26 @@ pub fn initialize_global_constructors_with_parent<'gc>(
     // Expose __createRealm__ as a native callable for cross-realm tests.
     env_set(mc, env, "__createRealm__", &Value::Function("__createRealm__".to_string()))?;
 
+    // $262.agent native hooks for test262 multi-agent tests
+    object_set_key_value(mc, env, "__agent_start", &Value::Function("__agent_start".to_string()))?;
+    object_set_key_value(mc, env, "__agent_broadcast", &Value::Function("__agent_broadcast".to_string()))?;
+    object_set_key_value(mc, env, "__agent_getReport", &Value::Function("__agent_getReport".to_string()))?;
+    object_set_key_value(mc, env, "__agent_sleep", &Value::Function("__agent_sleep".to_string()))?;
+    object_set_key_value(
+        mc,
+        env,
+        "__agent_monotonicNow",
+        &Value::Function("__agent_monotonicNow".to_string()),
+    )?;
+    object_set_key_value(
+        mc,
+        env,
+        "__agent_receiveBroadcast",
+        &Value::Function("__agent_receiveBroadcast".to_string()),
+    )?;
+    object_set_key_value(mc, env, "__agent_report", &Value::Function("__agent_report".to_string()))?;
+    object_set_key_value(mc, env, "__agent_leaving", &Value::Function("__agent_leaving".to_string()))?;
+
     #[cfg(feature = "os")]
     crate::js_os::initialize_os_module(mc, env)?;
 
@@ -495,6 +515,11 @@ where
     arena.mutate(|mc, root| {
         initialize_global_constructors(mc, &root.global_env)?;
 
+        // Reset agent state for test isolation (only on main thread, not agent threads)
+        if !crate::js_agent::is_agent_thread() {
+            crate::js_agent::reset_agent_state();
+        }
+
         env_set(mc, &root.global_env, "globalThis", &Value::Object(root.global_env))?;
         root.global_env.borrow_mut(mc).set_non_enumerable("globalThis");
         object_set_key_value(mc, &root.global_env, "this", &Value::Object(root.global_env))?;
@@ -673,6 +698,17 @@ where
                                 continue;
                             }
 
+                            // Keep event loop alive while Atomics.waitAsync promises are pending.
+                            // Background notification threads will wake us via EVENT_LOOP_WAKE.
+                            if crate::js_typedarray::has_pending_async_waiters() {
+                                let (lock, cv) = crate::js_promise::get_event_loop_wake();
+                                let mut guard = lock.lock().unwrap();
+                                *guard = false;
+                                let (_g, _res) = cv.wait_timeout(guard, std::time::Duration::from_millis(100)).unwrap();
+                                count += 1;
+                                continue;
+                            }
+
                             // If configured to wait for active handles (Node-like), and we have
                             // timers/intervals registered, keep the event loop alive until
                             // they are gone. We poll periodically and wait on the condvar