Revert "no more time threads"

This reverts commit b247994.

Author: fraidev

libs/core/runtime/jsruntime.rs

@@ -436,10 +436,8 @@ pub struct JsRuntimeState {
   pub(crate) function_templates: Rc<RefCell<FunctionTemplateData>>,
   pub(crate) callsite_prototype: RefCell<Option<v8::Global<v8::Object>>>,
   waker: Arc<AtomicWaker>,
-  /// Level-triggered flag set by the custom V8 platform when a foreground
-  /// task is posted. Checked and cleared each poll to ensure pumping even
-  /// if the edge-triggered AtomicWaker notification was lost.
-  has_foreground_task: Arc<std::sync::atomic::AtomicBool>,
+  /// Guards the 100ms safety-net timer so at most one is active at a time.
+  safety_net_active: Arc<std::sync::atomic::AtomicBool>,
   /// Accessed through [`JsRuntimeState::with_inspector`].
   inspector: RefCell<Option<Rc<JsRuntimeInspector>>>,
   has_inspector: Cell<bool>,
@@ -745,8 +743,6 @@ impl JsRuntime {
     // ...now let's set up ` JsRuntimeState`, we'll need to set some fields
     // later, after `JsRuntime` is all set up...
     let waker = op_state.waker.clone();
-    let has_foreground_task =
-      Arc::new(std::sync::atomic::AtomicBool::new(false));
     let op_state = Rc::new(RefCell::new(op_state));
     let (eval_context_get_code_cache_cb, eval_context_set_code_cache_cb) =
       options
@@ -769,7 +765,7 @@ impl JsRuntime {
         eval_context_set_code_cache_cb,
       ),
       waker: waker.clone(),
-      has_foreground_task: has_foreground_task.clone(),
+      safety_net_active: Arc::new(std::sync::atomic::AtomicBool::new(false)),
       // Some fields are initialized later after isolate is created
       inspector: None.into(),
       has_inspector: false.into(),
@@ -851,7 +847,6 @@ impl JsRuntime {
     setup::register_isolate_waker(
       setup::isolate_ptr_to_key(isolate_ptr),
       waker.clone(),
-      has_foreground_task,
     );
 
     // ...isolate is fully set up, we can forward its pointer to the ops to finish
@@ -2113,14 +2108,7 @@ impl JsRuntime {
     if has_inspector {
       self.inspector().poll_sessions_from_event_loop(cx);
     }
-    // Clear the foreground-task flag (set by the custom V8 platform callback).
-    // If it was set, we must pump the message loop regardless of other state.
-    let had_foreground_task = self
-      .inner
-      .state
-      .has_foreground_task
-      .swap(false, std::sync::atomic::Ordering::Relaxed);
-    if poll_options.pump_v8_message_loop || had_foreground_task {
+    if poll_options.pump_v8_message_loop {
       self.pump_v8_message_loop(scope)?;
     }
 
@@ -2277,6 +2265,27 @@ 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. Uses an OS thread (not
+    // tokio) to avoid depending on the async runtime being cooperative.
+    // The AtomicBool guard ensures at most one safety-net timer is active.
+    if pending_state.has_pending_background_tasks
+      && !self
+        .inner
+        .state
+        .safety_net_active
+        .swap(true, std::sync::atomic::Ordering::Relaxed)
+    {
+      let waker = cx.waker().clone();
+      let flag = self.inner.state.safety_net_active.clone();
+      std::thread::spawn(move || {
+        std::thread::sleep(std::time::Duration::from_millis(100));
+        flag.store(false, std::sync::atomic::Ordering::Relaxed);
+        waker.wake_by_ref();
+      });
+    }
+
     // Re-wake logic for next iteration
     #[allow(clippy::suspicious_else_formatting, clippy::if_same_then_else)]
     {

libs/core/runtime/setup.rs

@@ -32,69 +32,51 @@ pub(crate) fn isolate_ptr_to_key(ptr: v8::UnsafeRawIsolatePtr) -> usize {
   unsafe { std::mem::transmute::<v8::UnsafeRawIsolatePtr, usize>(ptr) }
 }
 
-/// Per-isolate waker state: an `AtomicWaker` for edge-triggered wakeups
-/// and an `AtomicBool` flag for level-triggered detection.
-///
-/// The `AtomicWaker` can lose wakes if `wake()` is called while the stored
-/// waker was already consumed (e.g. by the re-wake logic in the poll loop).
-/// The `AtomicBool` flag ensures the poll loop always sees that a foreground
-/// task was posted, even if the waker-based notification was lost.
-struct IsolateWakerEntry {
-  waker: std::sync::Arc<AtomicWaker>,
-  has_foreground_task: std::sync::Arc<AtomicBool>,
-}
-
-/// Global registry mapping isolate pointers to their waker state.
+/// Global registry mapping isolate pointers to their event loop wakers.
+/// When V8 posts a foreground task for an isolate, the callback looks up
+/// the waker here and wakes the event loop. Isolates that received a
+/// notification before their waker was registered are tracked in
+/// `pending_wakes` so `register_isolate_waker` can wake them immediately.
 struct IsolateWakerRegistry {
-  entries: HashMap<usize, IsolateWakerEntry>,
+  wakers: HashMap<usize, std::sync::Arc<AtomicWaker>>,
   pending_wakes: std::collections::HashSet<usize>,
 }
 
 static ISOLATE_WAKERS: std::sync::LazyLock<Mutex<IsolateWakerRegistry>> =
   std::sync::LazyLock::new(|| {
     Mutex::new(IsolateWakerRegistry {
-      entries: HashMap::new(),
+      wakers: HashMap::new(),
       pending_wakes: std::collections::HashSet::new(),
     })
   });
 
-/// Register a waker and foreground-task flag for an isolate.
-/// If a notification arrived before registration, the flag is set
-/// and the waker is triggered immediately.
+/// Register a waker for an isolate so foreground task notifications
+/// wake the correct event loop. If a notification arrived before
+/// registration, the waker is triggered immediately.
 pub fn register_isolate_waker(
   isolate_ptr: usize,
   waker: std::sync::Arc<AtomicWaker>,
-  has_foreground_task: std::sync::Arc<AtomicBool>,
 ) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
   if reg.pending_wakes.remove(&isolate_ptr) {
-    has_foreground_task.store(true, Ordering::Relaxed);
     waker.wake();
   }
-  reg.entries.insert(
-    isolate_ptr,
-    IsolateWakerEntry {
-      waker,
-      has_foreground_task,
-    },
-  );
+  reg.wakers.insert(isolate_ptr, waker);
 }
 
-/// Unregister an isolate's waker state (called on isolate drop).
+/// Unregister an isolate's waker (called on isolate drop).
 pub fn unregister_isolate_waker(isolate_ptr: usize) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
-  reg.entries.remove(&isolate_ptr);
+  reg.wakers.remove(&isolate_ptr);
   reg.pending_wakes.remove(&isolate_ptr);
 }
 
-/// Notify that a foreground task was posted for the given isolate.
-/// Sets the level-triggered flag and wakes the event loop.
-/// If the isolate's state is not yet registered, marks it as pending.
+/// Wake the event loop for a given isolate. If the isolate's waker
+/// is not yet registered, marks it as pending so registration wakes it.
 fn wake_isolate(key: usize) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
-  if let Some(entry) = reg.entries.get(&key) {
-    entry.has_foreground_task.store(true, Ordering::Relaxed);
-    entry.waker.wake();
+  if let Some(waker) = reg.wakers.get(&key) {
+    waker.wake();
   } else {
     reg.pending_wakes.insert(key);
   }