fix(repl): surface CDP protocol errors and fix race in wait_for_response (#33190)

## Summary

- The REPL's `wait_for_response` silently swallowed CDP error responses
(responses with an `"error"` field instead of `"result"`), converting
them to `null`. This made the `npm_packages` test failure on Windows
ARM64 impossible to diagnose — the actual V8 error was lost and replaced
by a confusing serde message (`invalid type: null, expected struct
EvaluateResponse`).
- Log CDP protocol errors via `eprintln!` so they appear in test stderr
output on the next CI failure
- Fix TOCTOU race: hold the lock across both the "check if ready" and
"register WaitingFor" steps in `wait_for_response` to prevent a response
from being overwritten between the two operations
- Apply the same fixes to the duplicated code in `hmr.rs`

## Motivation

The `integration::repl::npm_packages` test has become nearly constantly
failing on Windows ARM64 CI
([example](https://github.com/denoland/deno/actions/runs/24003416554/job/70004374515)).
The error output is:

```
"undefined\nerror: invalid type: null, expected struct EvaluateResponse\n" does not contain any of ["hello"]
```

This means V8's `Runtime.evaluate` returned a CDP protocol error, but
the actual error message was discarded. With this change, the next CI
failure will print the real V8 error to stderr, allowing us to identify
and fix the root cause.

---------

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

Author: bartlomieju

cli/tools/repl/session.rs

@@ -260,21 +260,35 @@ impl ReplSessionState {
   }
 
   async fn wait_for_response(&self, msg_id: i32) -> serde_json::Value {
-    if let Some(message_state) = self.0.lock().messages.remove(&msg_id) {
-      let InspectorMessageState::Ready(mut value) = message_state else {
-        unreachable!();
-      };
-      return value["result"].take();
-    }
+    let rx = {
+      let mut state = self.0.lock();
+      if let Some(message_state) = state.messages.remove(&msg_id) {
+        let InspectorMessageState::Ready(value) = message_state else {
+          unreachable!();
+        };
+        return Self::extract_result(value);
+      }
+      let (tx, rx) = oneshot::channel();
+      state
+        .messages
+        .insert(msg_id, InspectorMessageState::WaitingFor(tx));
+      rx
+    };
 
-    let (tx, rx) = oneshot::channel();
-    self
-      .0
-      .lock()
-      .messages
-      .insert(msg_id, InspectorMessageState::WaitingFor(tx));
-    let mut value = rx.await.unwrap();
-    value["result"].take()
+    let value = rx.await.unwrap();
+    Self::extract_result(value)
+  }
+
+  #[allow(clippy::print_stderr, reason = "diagnostic for flaky CDP responses")]
+  fn extract_result(mut value: serde_json::Value) -> serde_json::Value {
+    let result = value["result"].take();
+    if result.is_null() {
+      eprintln!(
+        "CDP response has null result. Full response: {}",
+        serde_json::to_string(&value).unwrap_or_default()
+      );
+    }
+    result
   }
 }
 
@@ -410,6 +424,17 @@ impl ReplSession {
   ) -> Value {
     let msg_id = next_msg_id();
     self.session.post_message(msg_id, method, params);
+
+    // Under Explicit microtask policy, V8's REPL-mode evaluation creates
+    // a promise whose resolution callback is a queued microtask. Without
+    // this checkpoint, GC can collect the weakly-held promise before the
+    // microtask drains, causing a "Promise was collected" CDP error.
+    self
+      .worker
+      .js_runtime
+      .v8_isolate()
+      .perform_microtask_checkpoint();
+
     let fut = self
       .state
       .wait_for_response(msg_id)
@@ -889,7 +914,7 @@ impl ReplSession {
           return_by_value: None,
           generate_preview: None,
           user_gesture: None,
-          await_promise: None,
+          await_promise: Some(true),
           throw_on_side_effect: None,
           timeout: None,
           disable_breaks: None,

cli/tools/run/hmr.rs

@@ -299,22 +299,35 @@ impl HmrRunner {
   }
 
   async fn wait_for_response(&self, msg_id: i32) -> serde_json::Value {
-    if let Some(message_state) = self.state.0.lock().messages.remove(&msg_id) {
-      let InspectorMessageState::Ready(mut value) = message_state else {
-        unreachable!();
-      };
-      return value["result"].take();
-    }
+    let rx = {
+      let mut state = self.state.0.lock();
+      if let Some(message_state) = state.messages.remove(&msg_id) {
+        let InspectorMessageState::Ready(value) = message_state else {
+          unreachable!();
+        };
+        return Self::extract_result(value);
+      }
+      let (tx, rx) = oneshot::channel();
+      state
+        .messages
+        .insert(msg_id, InspectorMessageState::WaitingFor(tx));
+      rx
+    };
 
-    let (tx, rx) = oneshot::channel();
-    self
-      .state
-      .0
-      .lock()
-      .messages
-      .insert(msg_id, InspectorMessageState::WaitingFor(tx));
-    let mut value = rx.await.unwrap();
-    value["result"].take()
+    let value = rx.await.unwrap();
+    Self::extract_result(value)
+  }
+
+  #[allow(clippy::print_stderr, reason = "diagnostic for flaky CDP responses")]
+  fn extract_result(mut value: serde_json::Value) -> serde_json::Value {
+    let result = value["result"].take();
+    if result.is_null() {
+      eprintln!(
+        "CDP response has null result. Full response: {}",
+        serde_json::to_string(&value).unwrap_or_default()
+      );
+    }
+    result
   }
 
   fn set_script_source(&mut self, script_id: &str, source: &str) -> i32 {

tests/integration/repl_tests.rs

@@ -922,8 +922,8 @@ fn npm_packages() {
       true,
     );
 
+    assert!(err.is_empty(), "stderr: {}\nstdout: {}", err, out);
     assert_contains!(out, "hello");
-    assert!(err.is_empty(), "Error: {}", err);
   }
 
   {
@@ -938,8 +938,8 @@ fn npm_packages() {
       true,
     );
 
+    assert!(err.is_empty(), "stderr: {}\nstdout: {}", err, out);
     assert_contains!(out, "hello");
-    assert!(err.is_empty(), "Error: {}", err);
   }
 
   {