feat(core): update v8 to 146.8.0 with foreground task ownership (#32771)

## Summary

- Updates the `v8` crate from 146.5.0 to 146.8.0 (includes
[rusty_v8#1934](denoland/rusty_v8#1934))
- Updates `DenoPlatformImpl` to receive `v8::Task` / `v8::IdleTask`
ownership from the C++ custom platform, instead of tasks being queued in
`DefaultPlatform`
- Tasks are queued per-isolate and drained/run directly on the event
loop, removing the need for `PumpMessageLoop`
- Follows up on #32450 by adapting deno_core to the new rusty_v8 task
ownership API

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bartlomieju

Cargo.lock

@@ -99,7 +99,7 @@ deno_task_shell = "=0.29.0"
 deno_terminal = "=0.2.3"
 deno_unsync = { version = "0.4.4", default-features = false }
 deno_whoami = "0.1.0"
-v8 = { version = "146.5.0", default-features = false }
+v8 = { version = "146.8.0", default-features = false }
 
 denokv_proto = "0.13.0"
 denokv_remote = "0.13.0"

Cargo.toml

@@ -22,7 +22,6 @@ use deno_config::deno_json::CompilerOptions;
 use deno_core::JsRuntime;
 use deno_core::ModuleSpecifier;
 use deno_core::OpState;
-use deno_core::PollEventLoopOptions;
 use deno_core::RuntimeOptions;
 use deno_core::anyhow::anyhow;
 use deno_core::convert::Smi;
@@ -5351,10 +5350,7 @@ fn run_tsc_thread(
           .lock()
           .await
           .js_runtime
-          .run_event_loop(PollEventLoopOptions {
-            wait_for_inspector: false,
-            pump_v8_message_loop: true,
-          })
+          .run_event_loop(Default::default())
           .await
         {
           log::error!("Error in TSC event loop: {e}");

cli/lsp/tsc.rs

@@ -22,7 +22,6 @@ use deno_ast::swc::ecma_visit::Visit;
 use deno_ast::swc::ecma_visit::VisitWith;
 use deno_ast::swc::ecma_visit::noop_visit_type;
 use deno_core::LocalInspectorSession;
-use deno_core::PollEventLoopOptions;
 use deno_core::anyhow::anyhow;
 use deno_core::error::AnyError;
 use deno_core::error::CoreError;
@@ -426,16 +425,7 @@ impl ReplSession {
     self
       .worker
       .js_runtime
-      .with_event_loop_future(
-        fut,
-        PollEventLoopOptions {
-          // NOTE(bartlomieju): this is an important bit; we don't want to pump V8
-          // message loop here, so that GC won't run. Otherwise, the resulting
-          // object might be GC'ed before we have a chance to inspect it.
-          pump_v8_message_loop: false,
-          ..Default::default()
-        },
-      )
+      .with_event_loop_future(fut, Default::default())
       .await
       .unwrap()
   }

cli/tools/repl/session.rs

@@ -182,7 +182,7 @@ impl InnerIsolateState {
 
     // Unregister isolate waker before dropping the isolate
     let isolate_ptr = unsafe { self.v8_isolate.as_raw_isolate_ptr() };
-    setup::unregister_isolate_waker(setup::isolate_ptr_to_key(isolate_ptr));
+    setup::unregister_isolate(setup::isolate_ptr_to_key(isolate_ptr));
 
     let state_ptr = self.v8_isolate.get_data(STATE_DATA_OFFSET);
     // SAFETY: We are sure that it's a valid pointer for whole lifetime of
@@ -457,7 +457,10 @@ pub struct JsRuntimeState {
   pub(crate) function_templates: Rc<RefCell<FunctionTemplateData>>,
   pub(crate) callsite_prototype: RefCell<Option<v8::Global<v8::Object>>>,
   waker: Arc<AtomicWaker>,
-  safety_net_active: Arc<std::sync::atomic::AtomicBool>,
+  /// Foreground V8 tasks queued by the custom platform. Shared with the
+  /// global isolate registry so background threads can push tasks, while
+  /// the event loop drains them without touching the global map.
+  foreground_tasks: setup::ForegroundTaskQueue,
   /// Accessed through [`JsRuntimeState::with_inspector`].
   inspector: RefCell<Option<Rc<JsRuntimeInspector>>>,
   has_inspector: Cell<bool>,
@@ -586,19 +589,9 @@ impl RuntimeOptions {
   }
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, Default)]
 pub struct PollEventLoopOptions {
   pub wait_for_inspector: bool,
-  pub pump_v8_message_loop: bool,
-}
-
-impl Default for PollEventLoopOptions {
-  fn default() -> Self {
-    Self {
-      wait_for_inspector: false,
-      pump_v8_message_loop: true,
-    }
-  }
 }
 
 #[derive(Default)]
@@ -785,7 +778,7 @@ impl JsRuntime {
         eval_context_set_code_cache_cb,
       ),
       waker: waker.clone(),
-      safety_net_active: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+      foreground_tasks: Default::default(),
       // Some fields are initialized later after isolate is created
       inspector: None.into(),
       has_inspector: false.into(),
@@ -862,12 +855,19 @@ impl JsRuntime {
 
     let isolate_ptr = unsafe { isolate.as_raw_isolate_ptr() };
 
-    // Register this isolate's waker so the custom platform can wake
-    // the event loop when V8 posts foreground tasks from background threads.
-    setup::register_isolate_waker(
-      setup::isolate_ptr_to_key(isolate_ptr),
-      waker.clone(),
-    );
+    // Register this isolate in the global platform registry so V8 background
+    // threads can queue foreground tasks. The task queue Arc is already shared
+    // with JsRuntimeState (created above) so the event loop can drain it
+    // without touching the global map.
+    // Not all contexts have a tokio runtime (e.g. snapshot creation, unit tests).
+    if let Ok(handle) = tokio::runtime::Handle::try_current() {
+      setup::register_isolate(
+        setup::isolate_ptr_to_key(isolate_ptr),
+        waker.clone(),
+        handle,
+        state_rc.foreground_tasks.clone(),
+      );
+    }
 
     // ...isolate is fully set up, we can forward its pointer to the ops to finish
     // their' setup...
@@ -1902,32 +1902,6 @@ impl JsRuntime {
     }
   }
 
-  fn pump_v8_message_loop(
-    &self,
-    scope: &mut v8::PinScope,
-  ) -> Result<(), Box<JsError>> {
-    while v8::Platform::pump_message_loop(
-      &v8::V8::get_current_platform(),
-      scope,
-      false, // don't block if there are no tasks
-    ) {
-      // do nothing
-    }
-
-    v8::tc_scope!(let tc_scope, scope);
-
-    let context_state = JsRealm::state_from_scope(tc_scope);
-    if !context_state.has_tick_scheduled() {
-      tc_scope.perform_microtask_checkpoint();
-    }
-    match tc_scope.exception() {
-      None => Ok(()),
-      Some(exception) => {
-        exception_to_err_result(tc_scope, exception, false, true)
-      }
-    }
-  }
-
   pub fn maybe_init_inspector(&mut self) {
     let inspector = &mut self.inner.state.inspector.borrow_mut();
     if inspector.is_some() {
@@ -2130,12 +2104,31 @@ impl JsRuntime {
     let has_inspector = self.inner.state.has_inspector.get();
     self.inner.state.waker.register(cx.waker());
 
-    // Pre-phase: Inspector + V8 message loop pump
+    // Pre-phase: Inspector + drain foreground tasks + microtask checkpoint
     if has_inspector {
       self.inspector().poll_sessions_from_event_loop(cx);
     }
-    if poll_options.pump_v8_message_loop {
-      self.pump_v8_message_loop(scope)?;
+    {
+      // Drain and run foreground tasks queued by the custom V8 platform.
+      // Uses the local Arc shared with the registry — no global map lookup.
+      let tasks =
+        std::mem::take(&mut *self.inner.state.foreground_tasks.lock().unwrap());
+      for task in tasks {
+        task.run();
+      }
+
+      v8::tc_scope!(let tc_scope, scope);
+      let context_state = JsRealm::state_from_scope(tc_scope);
+      if !context_state.has_tick_scheduled() {
+        tc_scope.perform_microtask_checkpoint();
+      }
+      if let Some(exception) = tc_scope.exception() {
+        return Poll::Ready(Err(
+          exception_to_err_result::<()>(tc_scope, exception, false, true)
+            .unwrap_err()
+            .into(),
+        ));
+      }
     }
 
     let realm = &self.inner.main_realm;
@@ -2291,24 +2284,6 @@ impl JsRuntime {
       scope.perform_microtask_checkpoint();
     }
 
-    // Safety net: if V8 has pending background tasks (e.g. module compilation),
-    // schedule a delayed wake to pump the message loop in case the platform
-    // callback was missed due to a race condition.
-    if pending_state.has_pending_background_tasks
-      && !self
-        .inner
-        .state
-        .safety_net_active
-        .swap(true, std::sync::atomic::Ordering::SeqCst)
-    {
-      cx.waker().wake_by_ref();
-      self
-        .inner
-        .state
-        .safety_net_active
-        .store(false, std::sync::atomic::Ordering::SeqCst);
-    }
-
     // Re-wake logic for next iteration
     #[allow(
       clippy::suspicious_else_formatting,