Skip to content

The headless browser for AI agents and web scraping

Allow CDP commands while evaluations await promises

SGavrl17dcbe16d1d1
diff --git a/crates/obscura-cdp/src/dispatch.rs b/crates/obscura-cdp/src/dispatch.rs
index 1ffea475..dc7f7dbb 100644
--- a/crates/obscura-cdp/src/dispatch.rs
+++ b/crates/obscura-cdp/src/dispatch.rs
@@ -737,6 +737,14 @@ fn is_v8_free_method(method: &str) -> bool {
}
pub async fn dispatch(req: &CdpRequest, ctx: &mut CdpContext) -> CdpResponse {
+ dispatch_with_deferred(req, ctx, None).await
+}
+
+pub(crate) async fn dispatch_with_deferred(
+ req: &CdpRequest,
+ ctx: &mut CdpContext,
+ deferred: Option<&mut Option<domains::runtime::DeferredEvaluation>>,
+) -> CdpResponse {
// headless_chrome (and older Puppeteer) wrap every CDP call inside
// Target.sendMessageToTarget. Unwrap and recurse BEFORE acquiring the
// per-connection V8 lock — the recursive dispatch will acquire it for the
@@ -816,6 +824,18 @@ pub async fn dispatch(req: &CdpRequest, ctx: &mut CdpContext) -> CdpResponse {
"DOMSnapshot" => {
domains::domsnapshot::handle(method, &req.params, ctx, &req.session_id).await
}
+ "Runtime" if deferred.is_some() && matches!(method, "evaluate" | "callFunctionOn")
+ && req.params.get("awaitPromise").and_then(|value| value.as_bool()) == Some(true) => {
+ match domains::runtime::start_awaited_evaluation(method, &req.params, ctx, &req.session_id, cmd_budget_ms).await {
+ Ok(Some(evaluation)) if evaluation.ready(ctx) => evaluation.finish(ctx, &req.session_id).await,
+ Ok(Some(evaluation)) => {
+ *deferred.unwrap() = Some(evaluation);
+ Ok(json!({}))
+ }
+ Ok(None) => domains::runtime::handle(method, &req.params, ctx, &req.session_id).await,
+ Err(error) => Err(error),
+ }
+ }
"Runtime" => domains::runtime::handle(method, &req.params, ctx, &req.session_id).await,
"Network" => domains::network::handle(method, &req.params, ctx, &req.session_id).await,
"Fetch" => domains::fetch::handle(method, &req.params, ctx, &req.session_id).await,
diff --git a/crates/obscura-cdp/src/domains/runtime.rs b/crates/obscura-cdp/src/domains/runtime.rs
index 960a595f..a89a54ec 100644
--- a/crates/obscura-cdp/src/domains/runtime.rs
+++ b/crates/obscura-cdp/src/domains/runtime.rs
@@ -5,6 +5,89 @@ use serde_json::{json, Value};
use crate::dispatch::CdpContext;
+pub(crate) struct DeferredEvaluation {
+ pub(crate) page_id: String,
+ pending: obscura_js::runtime::PendingCdpEvaluation,
+ return_by_value: bool,
+ pub(crate) deadline: tokio::time::Instant,
+ command_deadline: Option<tokio::time::Instant>,
+ timeout_ms: u64,
+ method: String,
+}
+
+impl DeferredEvaluation {
+ pub(crate) fn ready(&self, ctx: &mut CdpContext) -> bool {
+ if tokio::time::Instant::now() >= self.deadline { return true; }
+ let Some(js) = ctx.get_page_mut(&self.page_id).and_then(|page| page.js.as_mut()) else { return true; };
+ !js.has_cdp_evaluation(&self.pending) || js.cdp_evaluation_ready(&self.pending)
+ }
+
+ pub(crate) async fn finish(self, ctx: &mut CdpContext, session_id: &Option<String>) -> Result<Value, String> {
+ let js = ctx.get_page_mut(&self.page_id).and_then(|page| page.js.as_mut())
+ .ok_or("Execution context was destroyed")?;
+ if !js.has_cdp_evaluation(&self.pending) {
+ return Err("Execution context was destroyed".into());
+ }
+ let remaining = self.command_deadline.map(|deadline| deadline.saturating_duration_since(tokio::time::Instant::now()));
+ if remaining.is_some_and(|budget| budget.is_zero()) {
+ js.cancel_cdp_evaluation(self.pending);
+ return Err("Runtime evaluation exceeded its command budget".into());
+ }
+ if !js.cdp_evaluation_ready(&self.pending) {
+ js.cancel_cdp_evaluation(self.pending);
+ return Err(format!("Runtime.{} promise did not settle within {}ms", self.method, self.timeout_ms));
+ }
+ let watchdog = remaining.map(|budget| obscura_js::runtime::spawn_watchdog(js.isolate_handle(), budget));
+ let result = match js.finish_cdp_evaluation(self.pending, self.return_by_value) {
+ Ok(info) => emit_post_eval_nav(ctx, session_id).await.map(|_| evaluation_reply(&info)),
+ Err(error) => Err(error),
+ };
+ if watchdog.is_some_and(|watchdog| watchdog.stop()) {
+ if let Some(js) = ctx.get_page_mut(&self.page_id).and_then(|page| page.js.as_mut()) {
+ js.cancel_termination();
+ }
+ return Err("Runtime result serialization exceeded its task budget".into());
+ }
+ result
+ }
+}
+
+pub(crate) async fn start_awaited_evaluation(
+ method: &str,
+ params: &Value,
+ ctx: &mut CdpContext,
+ session_id: &Option<String>,
+ command_budget_ms: u64,
+) -> Result<Option<DeferredEvaluation>, String> {
+ let field = if method == "evaluate" { "contextId" } else { "executionContextId" };
+ validate_context(params, field, ctx, session_id, method)?;
+ let return_by_value = params.get("returnByValue").and_then(Value::as_bool).unwrap_or(false);
+ let timeout_ms = params.get("timeout").and_then(Value::as_u64).unwrap_or(30_000);
+ let deadline = tokio::time::Instant::now() + std::time::Duration::from_millis(timeout_ms);
+ let command_deadline = (command_budget_ms != 0).then(|| tokio::time::Instant::now() + std::time::Duration::from_millis(command_budget_ms));
+ let deadline = command_deadline.map_or(deadline, |command| deadline.min(command));
+ let page = ctx.get_session_page_mut(session_id).ok_or("No page")?;
+ let Some(js) = page.js.as_mut() else { return Ok(None); };
+ let evaluation = if method == "evaluate" {
+ js.start_cdp_evaluation(params.get("expression").and_then(Value::as_str).ok_or("expression required")?, return_by_value, true)?
+ } else {
+ js.start_cdp_call(
+ params.get("functionDeclaration").and_then(Value::as_str).unwrap_or("() => undefined"),
+ params.get("objectId").and_then(Value::as_str),
+ params.get("arguments").and_then(Value::as_array).map(Vec::as_slice).unwrap_or(&[]),
+ return_by_value, true,
+ )?
+ };
+ let obscura_js::runtime::CdpEvaluation::Pending(pending) = evaluation else {
+ return Err("Awaited evaluation did not create a pending record".into());
+ };
+ // Finish this task's promise reactions before a script-initiated navigation.
+ js.resolve_promises_until(|js| js.cdp_evaluation_ready(&pending), 0).await;
+ Ok(Some(DeferredEvaluation {
+ page_id: page.id.clone(), pending, return_by_value, deadline, command_deadline, timeout_ms, method: method.into(),
+ }))
+}
+
async fn with_live_peers<'a, F, Fut>(
ctx: &'a mut CdpContext,
session_id: &Option<String>,
diff --git a/crates/obscura-cdp/src/server.rs b/crates/obscura-cdp/src/server.rs
index 93fd8f84..fc35c1a0 100644
--- a/crates/obscura-cdp/src/server.rs
+++ b/crates/obscura-cdp/src/server.rs
@@ -23,6 +23,13 @@ use crate::dispatch::{self, CdpContext};
// is reached we return an explicit error response rather than silently dropping.
const MAX_DEFERRED_MESSAGES: usize = 256;
+struct PendingRuntimeReply {
+ id: u64,
+ session_id: Option<String>,
+ reply_tx: mpsc::UnboundedSender<String>,
+ evaluation: crate::domains::runtime::DeferredEvaluation,
+}
+
// The WS-stream forwarding channel must also be bounded: if the LocalSet
// (CDP processor + nav tasks) stalls, the accept thread keeps pushing
// `std::net::TcpStream`s into the queue. An unbounded channel would let
@@ -1248,8 +1255,27 @@ async fn cdp_processor(
let mut runtime_pump_armed = false;
let mut runtime_pump_error_streak = 0_u8;
let mut idle_pages = HashSet::new();
+ let mut pending_runtime = Vec::<PendingRuntimeReply>::new();
loop {
+ let mut index = 0;
+ while index < pending_runtime.len() {
+ if !pending_runtime[index].evaluation.ready(&mut ctx) { index += 1; continue; }
+ let pending = pending_runtime.remove(index);
+ let _guard = ctx.v8_lock.clone().lock_owned().await;
+ let result = pending.evaluation.finish(&mut ctx, &pending.session_id).await;
+ idle_pages.clear();
+ runtime_pump_armed = ctx.pages.iter().any(|page| page.has_js());
+ dispatch::drain_runtime_events(&mut ctx);
+ dispatch::drain_binding_calls(&mut ctx);
+ dispatch::drain_frame_events(&mut ctx);
+ forward_pending_events(&mut ctx, Some(&pending.reply_tx));
+ let response = match result {
+ Ok(value) => crate::types::CdpResponse::success(pending.id, value, pending.session_id),
+ Err(error) => crate::types::CdpResponse::error(pending.id, -32000, error, pending.session_id),
+ };
+ if let Ok(json) = serde_json::to_string(&response) { let _ = pending.reply_tx.send(json); }
+ }
// Drain any deferred messages from the previous interception window
// before pulling new ones off the wire. Each is processed with no
// nav-task spawn_local in flight, so this connection's only entered
@@ -1259,6 +1285,7 @@ async fn cdp_processor(
} else {
let screencast_active = has_active_screencast(&ctx);
let has_intercept_rx = intercept_rx.is_some();
+ let evaluation_deadline = pending_runtime.iter().map(|pending| pending.evaluation.deadline).min();
tokio::select! {
biased;
msg = rx.recv() => match msg {
@@ -1269,6 +1296,12 @@ async fn cdp_processor(
tracing::info!("Shutdown signal received (connection processor)");
break;
},
+ _ = async {
+ match evaluation_deadline {
+ Some(deadline) => tokio::time::sleep_until(deadline).await,
+ None => std::future::pending().await,
+ }
+ } => None,
pump_result = pump_live_page_event_loop(&mut ctx, &mut idle_pages), if runtime_pump_armed => {
match pump_result {
Ok(reached_idle) => {
@@ -1326,10 +1359,14 @@ async fn cdp_processor(
}
}, if has_intercept_rx => {
if let Some(reply_tx) = connection_reply_tx.as_ref() {
+ let route = pending_runtime.iter()
+ .find(|pending| pending.evaluation.page_id == intercepted.page_id)
+ .and_then(|pending| ctx.pages.iter().find(|page| page.id == intercepted.page_id)
+ .map(|page| (page.id.as_str(), page.frame_id.as_str(), pending.session_id.clone())));
emit_intercepted_request(
intercepted,
&ctx,
- None,
+ route,
reply_tx,
&mut intercepted_paused,
);
@@ -1383,16 +1420,6 @@ async fn cdp_processor(
&mut intercept_rx, &mut intercepted_paused,
&mut deferred, true,
).await;
- } else if ctx.pages.iter().any(|page| page.intercept_enabled)
- && serde_json::from_str::<CdpRequest>(&cdp_msg.text).is_ok_and(|req| {
- matches!(req.method.as_str(), "Runtime.evaluate" | "Runtime.callFunctionOn")
- && req.params.get("awaitPromise").and_then(|v| v.as_bool()) == Some(true)
- })
- {
- process_awaited_with_interception(
- &cdp_msg.text, &mut ctx, &cdp_msg.reply_tx, &mut rx,
- &mut intercept_rx, &mut intercepted_paused, &mut deferred,
- ).await;
} else {
let fetch_was_resolved = cdp_msg.text.contains("Fetch.")
&& handle_fetch_resolution(
@@ -1401,7 +1428,7 @@ async fn cdp_processor(
&mut intercepted_paused,
);
if !fetch_was_resolved {
- process_cdp_message(&cdp_msg.text, &mut ctx, &cdp_msg.reply_tx).await;
+ process_cdp_message_with_pending(&cdp_msg.text, &mut ctx, &cdp_msg.reply_tx, Some(&mut pending_runtime)).await;
}
}
}
@@ -2139,73 +2166,19 @@ async fn process_with_interception(
}
}
-async fn process_awaited_with_interception(
+async fn process_cdp_message(
text: &str,
ctx: &mut CdpContext,
reply_tx: &mpsc::UnboundedSender<String>,
- rx: &mut mpsc::UnboundedReceiver<ServerMessage>,
- intercept_rx: &mut Option<mpsc::UnboundedReceiver<obscura_js::ops::InterceptedRequest>>,
- intercepted_paused: &mut HashMap<String, tokio::sync::oneshot::Sender<obscura_js::ops::InterceptResolution>>,
- deferred: &mut std::collections::VecDeque<ServerMessage>,
) {
- // The evaluation owns ctx (and V8) until it completes. Snapshot only routing
- // metadata so request replies can unblock it without entering another isolate.
- let requesting_session = serde_json::from_str::<CdpRequest>(text).ok()
- .and_then(|request| request.session_id);
- let routes: HashMap<_, _> = ctx.pages.iter().filter_map(|page| {
- let session_id = requesting_session.as_ref()
- .filter(|session| ctx.sessions.get(*session) == Some(&page.id))
- .or_else(|| ctx.sessions.iter().find(|(_, page_id)| **page_id == page.id)
- .map(|(session, _)| session))?;
- let observers = crate::domains::page::network_observer_sessions(
- ctx, &page.id, &Some(session_id.clone()),
- );
- Some((page.id.clone(), (page.frame_id.clone(), session_id.clone(), observers)))
- }).collect();
- let command = process_cdp_message(text, ctx, reply_tx);
- tokio::pin!(command);
- loop {
- tokio::select! {
- () = &mut command => break,
- Some(intercepted) = async {
- match intercept_rx.as_mut() {
- Some(receiver) => receiver.recv().await,
- None => std::future::pending().await,
- }
- } => {
- let (route, observers) = routes.get(&intercepted.page_id)
- .map(|(frame_id, session_id, observers)| (
- Some((frame_id.as_str(), Some(session_id.clone()))), observers.as_slice(),
- )).unwrap_or((None, &[]));
- emit_routed_intercepted_request(intercepted, route, observers, reply_tx, intercepted_paused);
- }
- Some(message) = rx.recv() => {
- if let ServerMessage::Cdp(msg) = &message {
- if handle_fetch_resolution(&msg.text, &msg.reply_tx, intercepted_paused) {
- continue;
- }
- if deferred.len() >= MAX_DEFERRED_MESSAGES {
- if let Ok(req) = serde_json::from_str::<CdpRequest>(&msg.text) {
- let response = crate::types::CdpResponse::error(
- req.id, -32000, "Server busy: evaluation in progress, try again later".into(), req.session_id,
- );
- if let Ok(json) = serde_json::to_string(&response) {
- let _ = msg.reply_tx.send(json);
- }
- }
- continue;
- }
- }
- deferred.push_back(message);
- }
- }
- }
+ process_cdp_message_with_pending(text, ctx, reply_tx, None).await;
}
-async fn process_cdp_message(
+async fn process_cdp_message_with_pending(
text: &str,
ctx: &mut CdpContext,
reply_tx: &mpsc::UnboundedSender<String>,
+ pending_runtime: Option<&mut Vec<PendingRuntimeReply>>,
) {
let req: CdpRequest = match serde_json::from_str(text) {
Ok(r) => r,
@@ -2218,7 +2191,16 @@ async fn process_cdp_message(
tracing::debug!("CDP: {} (id={}, s={:?})", req.method, req.id, req.session_id);
service_live_page_render_resources(ctx);
- let response = dispatch::dispatch(&req, ctx).await;
+ let mut evaluation = None;
+ let is_awaited = matches!(req.method.as_str(), "Runtime.evaluate" | "Runtime.callFunctionOn")
+ && req.params.get("awaitPromise").and_then(|value| value.as_bool()) == Some(true);
+ let response = if pending_runtime.as_ref().is_some_and(|pending| pending.len() >= MAX_DEFERRED_MESSAGES) && is_awaited {
+ crate::types::CdpResponse::error(req.id, -32000, "Too many pending evaluations".into(), req.session_id.clone())
+ } else if pending_runtime.is_some() {
+ dispatch::dispatch_with_deferred(&req, ctx, Some(&mut evaluation)).await
+ } else {
+ dispatch::dispatch(&req, ctx).await
+ };
service_live_page_render_resources(ctx);
// Chromium CDP semantics: events emitted as a side-effect of a command
@@ -2233,8 +2215,12 @@ async fn process_cdp_message(
}
}
- if let Ok(json) = serde_json::to_string(&response) {
- let _ = reply_tx.send(json);
+ if let (Some(evaluation), Some(pending)) = (evaluation, pending_runtime) {
+ pending.push(PendingRuntimeReply {
+ id: req.id, session_id: req.session_id, reply_tx: reply_tx.clone(), evaluation,
+ });
+ } else {
+ if let Ok(json) = serde_json::to_string(&response) { let _ = reply_tx.send(json); }
}
}
@@ -3198,6 +3184,97 @@ mod tests {
}).await;
}
+ #[tokio::test(flavor = "current_thread")]
+ async fn pending_runtime_evaluations_do_not_block_their_resolver() {
+ use super::{cdp_processor, CdpContext, CdpMessage, ServerMessage};
+ use serde_json::Value;
+ use std::time::Duration;
+ use tokio::sync::mpsc;
+ tokio::task::LocalSet::new().run_until(async {
+ let (server_tx, server_rx) = mpsc::unbounded_channel();
+ let (reply_tx, mut reply_rx) = mpsc::unbounded_channel();
+ let processor = tokio::task::spawn_local(cdp_processor(
+ server_rx, CdpContext::new().default_context,
+ std::sync::Arc::new(tokio::sync::Notify::new()),
+ ));
+ server_tx.send(ServerMessage::NewConnection { reply_tx: reply_tx.clone() }).unwrap();
+ reply_rx.recv().await.unwrap();
+ let send = |value: Value| {
+ server_tx.send(ServerMessage::Cdp(CdpMessage {
+ text: value.to_string(), reply_tx: reply_tx.clone(),
+ })).unwrap();
+ };
+ send(json!({"id": 1, "method": "Target.createTarget", "params": {"url": "about:blank"}}));
+ let mut session = None;
+ loop {
+ let value: Value = serde_json::from_str(&reply_rx.recv().await.unwrap()).unwrap();
+ if let Some(id) = value["params"]["sessionId"].as_str() { session = Some(id.to_string()); }
+ if value["id"] == 1 { break; }
+ }
+ let session = session.expect("attached session");
+ for (id, method, params) in [
+ (2, "Runtime.evaluate", json!({"expression": "new Promise(resolve => globalThis.releasePending = resolve)", "awaitPromise": true, "returnByValue": true})),
+ (3, "Runtime.callFunctionOn", json!({"functionDeclaration": "function(){ return new Promise(resolve => globalThis.releasePending = resolve) }", "awaitPromise": true, "returnByValue": true})),
+ ] {
+ send(json!({"id": id, "method": method, "sessionId": session, "params": params}));
+ send(json!({"id": id + 10, "method": "Runtime.evaluate", "sessionId": session,
+ "params": {"expression": "releasePending(42); 'released'", "returnByValue": true}}));
+ let mut resolved = false;
+ let mut released = false;
+ tokio::time::timeout(Duration::from_secs(2), async {
+ while !resolved || !released {
+ let value: Value = serde_json::from_str(&reply_rx.recv().await.unwrap()).unwrap();
+ if value["id"] == id {
+ assert!(value.get("error").is_none(), "{value}");
+ assert_eq!(value["result"]["result"]["value"].as_f64(), Some(42.0));
+ resolved = true;
+ } else if value["id"] == id + 10 {
+ assert_eq!(value["result"]["result"]["value"], "released", "{value}");
+ released = true;
+ }
+ }
+ }).await.expect("a pending promise must not block the command that resolves it");
+ }
+ send(json!({"id": 100, "method": "Runtime.evaluate", "sessionId": session,
+ "params": {"expression": "location.href='data:text/html,<title>next</title>'; 42", "awaitPromise": true, "returnByValue": true}}));
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ let value: Value = serde_json::from_str(&reply_rx.recv().await.unwrap()).unwrap();
+ if value["id"] == 100 {
+ assert!(value.get("error").is_none(), "plain return must precede navigation: {value}");
+ assert_eq!(value["result"]["result"]["value"].as_f64(), Some(42.0));
+ break;
+ }
+ }
+ }).await.expect("script-initiated navigation must not discard a settled reply");
+ std::env::set_var("OBSCURA_CDP_COMMAND_TIMEOUT_MS", "50");
+ send(json!({"id": 200, "method": "Runtime.evaluate", "sessionId": session,
+ "params": {"expression": "new Promise(resolve => setTimeout(() => resolve({get trap(){while(true){}}}), 10))", "awaitPromise": true, "returnByValue": true}}));
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ let value: Value = serde_json::from_str(&reply_rx.recv().await.unwrap()).unwrap();
+ if value["id"] == 200 {
+ assert!(value.get("error").is_some(), "a deferred result getter must remain watchdog-bounded: {value}");
+ break;
+ }
+ }
+ }).await.expect("deferred result serialization must not hang the worker");
+ send(json!({"id": 201, "method": "Runtime.evaluate", "sessionId": session,
+ "params": {"expression": "21*2", "returnByValue": true}}));
+ tokio::time::timeout(Duration::from_secs(2), async {
+ loop {
+ let value: Value = serde_json::from_str(&reply_rx.recv().await.unwrap()).unwrap();
+ if value["id"] == 201 {
+ assert_eq!(value["result"]["result"]["value"].as_f64(), Some(42.0), "{value}");
+ break;
+ }
+ }
+ }).await.expect("the page must remain usable after a result getter is terminated");
+ drop(server_tx);
+ tokio::time::timeout(Duration::from_secs(2), processor).await.unwrap().unwrap();
+ }).await;
+ }
+
#[tokio::test(flavor = "current_thread")]
async fn awaited_runtime_requests_keep_servicing_route_replies() {
use super::{cdp_processor, CdpContext, CdpMessage, ServerMessage};
@@ -3278,7 +3355,6 @@ mod tests {
}
if value["method"] == "Network.loadingFinished" && value["sessionId"] == session { finished += 1; }
if value["id"] == 10 + id {
- assert!(completed, "unrelated V8 work must stay deferred");
assert_eq!(value["result"]["result"]["value"].as_f64(), Some(42.0));
deferred_completed = true;
}
diff --git a/crates/obscura-js/src/runtime.rs b/crates/obscura-js/src/runtime.rs
index 43b94de3..1c392ef0 100644
--- a/crates/obscura-js/src/runtime.rs
+++ b/crates/obscura-js/src/runtime.rs
@@ -2823,6 +2823,24 @@ impl ObscuraJsRuntime {
self.finish_cdp_result(&meta_json, &oid).map(CdpEvaluation::Complete)
}
+ #[doc(hidden)]
+ pub fn has_cdp_evaluation(&self, pending: &PendingCdpEvaluation) -> bool {
+ self.pending_cdp_evaluations.contains_key(&pending.object_id)
+ }
+
+ fn has_ready_cdp_evaluations(&mut self) -> bool {
+ if self.pending_cdp_evaluations.is_empty() { return false; }
+ let records: Vec<_> = self.pending_cdp_evaluations.values().cloned().collect();
+ let mut entered = self.runtime();
+ let context = entered.main_context();
+ v8::scope_with_context!(scope, entered.v8_isolate(), context);
+ let Some(key) = v8::String::new(scope, "done") else { return false; };
+ records.into_iter().any(|record| {
+ let Ok(record) = v8::Local::<v8::Object>::try_from(v8::Local::new(scope, record)) else { return false; };
+ record.get(scope, key.into()).is_some_and(|value| value.is_true())
+ })
+ }
+
#[doc(hidden)]
pub fn cdp_evaluation_ready(&mut self, pending: &PendingCdpEvaluation) -> bool {
let Some(record) = self.pending_cdp_evaluations.get(&pending.object_id).cloned() else {
@@ -3772,6 +3790,9 @@ impl ObscuraJsRuntime {
return Err("JavaScript heap limit exceeded; execution terminated".into());
}
+ // Publish settled protocol replies before parking on unrelated page work.
+ if self.has_ready_cdp_evaluations() { return Ok(false); }
+
let isolate_handle = self.isolate_handle();
let mut waiting_for_wake = false;
let result = std::future::poll_fn(|cx| {
@@ -3790,6 +3811,9 @@ impl ObscuraJsRuntime {
"autonomous browser task exceeded its task budget".into(),
));
}
+ if self.has_ready_cdp_evaluations() {
+ return std::task::Poll::Ready(Ok(false));
+ }
match tick {
std::task::Poll::Ready(Ok(())) => std::task::Poll::Ready(Ok(true)),
// A page task error (uncaught exception, unhandled rejection)