Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

fix(cdp): limit Runtime stack capture depth

ldm00ef12dab97b0
diff --git a/moli-cdp-smoke/README.md b/moli-cdp-smoke/README.md
index 28705f948..ce53ff11d 100644
--- a/moli-cdp-smoke/README.md
+++ b/moli-cdp-smoke/README.md
@@ -181,15 +181,16 @@ managed Linux server, so the resource assertions are mandatory there.
Covered well:
- The default raw `debugger-breakpoints`, `runtime-exception`, and
- `file-chooser` groups preserve six raw-CDP contracts covering seven Lexbench
- task regressions at the public process boundary, and add two multi-attachment
- Runtime exception contracts. They dispatch `Debugger.getPossibleBreakpoints`,
+ `file-chooser` groups preserve focused Lexbench regressions at the public
+ process boundary, including multi-attachment Runtime exception contracts.
+ They dispatch `Debugger.getPossibleBreakpoints`,
`setBreakpoint`, `removeBreakpoint`, and `setBreakpointByUrl` while the Page
is normally running, require an uncaught timer error to publish
`Runtime.exceptionThrown` without a follow-up command, verify that each
Runtime-enabled attachment receives the target-owned exception while a
- disabled peer does not, and require a user-gesture file-input activation to
- publish the session-scoped `Page.fileChooserOpened` event.
+ disabled peer does not, keep `Runtime.enable` from making Error stack cost
+ track JavaScript stack depth, and require a user-gesture file-input activation
+ to publish the session-scoped `Page.fileChooserOpened` event.
- The default raw `url-policy` group holds the hosted local-file boundary at the
public process edge. It requires an exact session-routed `Page.navigate`
`-32000` error with no lifecycle or document replacement, verifies page
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/protocol_regressions.py b/moli-cdp-smoke/moli_cdp_smoke/groups/protocol_regressions.py
index d0db66a31..8fc7e054a 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/groups/protocol_regressions.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/protocol_regressions.py
@@ -151,6 +151,8 @@ async def run_runtime_exception_group(
# asynchronous exception.
enable_id = await client.send("Runtime.enable", session_id=session_id)
await client.recv_until_id(enable_id, timeout=5)
+ stack_cost = await _runtime_enable_stack_cost_probe(client, session_id)
+ record(results, "raw_cdp_runtime_enable_stack_cost", stack_cost)
marker = "moli-smoke-async-exception"
exceptions = await _schedule_async_exception_and_collect(
client,
@@ -209,6 +211,90 @@ async def run_runtime_exception_group(
await _close_client(client)
+async def _runtime_enable_stack_cost_probe(
+ client: RawCdpClient,
+ session_id: str,
+) -> dict[str, Any]:
+ evaluate_id = await client.send(
+ "Runtime.evaluate",
+ {
+ "expression": r"""
+(() => {
+ const measureOnce = () => {
+ let sink = 0;
+ const sample = depth => {
+ if (depth > 0) return sample(depth - 1);
+ const started = performance.now();
+ for (let index = 0; index < 3; index += 1) {
+ try {
+ throw new Error('runtime-stack-cost-probe');
+ } catch (error) {
+ sink += error.stack.length;
+ }
+ }
+ return (performance.now() - started) / 3;
+ };
+
+ for (let index = 0; index < 50; index += 1) sample(50);
+ const depths = [];
+ const costs = [];
+ for (let depth = 10; depth <= 200; depth += 10) {
+ let cost = 0;
+ for (let repeat = 0; repeat < 4; repeat += 1) cost += sample(depth);
+ depths.push(depth);
+ costs.push(cost / 4);
+ }
+
+ const mean = values =>
+ values.reduce((total, value) => total + value, 0) / values.length;
+ const meanDepth = mean(depths);
+ const meanCost = mean(costs);
+ let covariance = 0;
+ let depthVariance = 0;
+ let costVariance = 0;
+ for (let index = 0; index < depths.length; index += 1) {
+ const depthDelta = depths[index] - meanDepth;
+ const costDelta = costs[index] - meanCost;
+ covariance += depthDelta * costDelta;
+ depthVariance += depthDelta * depthDelta;
+ costVariance += costDelta * costDelta;
+ }
+ const slope = depthVariance === 0 ? 0 : covariance / depthVariance;
+ const rSquared = depthVariance === 0 || costVariance === 0
+ ? 0
+ : (covariance * covariance) / (depthVariance * costVariance);
+ return {rSquared, slope, sink};
+ };
+ return [measureOnce(), measureOnce(), measureOnce()];
+})()
+""",
+ "returnByValue": True,
+ },
+ session_id=session_id,
+ )
+ response, _messages = await client.recv_until_id(evaluate_id, timeout=5)
+ if "error" in response:
+ raise SmokeError(f"Runtime stack-cost probe failed: {response}")
+ probes = response.get("result", {}).get("result", {}).get("value")
+ if not isinstance(probes, list) or len(probes) != 3:
+ raise SmokeError(f"Runtime stack-cost probe returned invalid samples: {response}")
+ try:
+ ordered_r_squared = sorted(float(probe["rSquared"]) for probe in probes)
+ except (KeyError, TypeError, ValueError) as error:
+ raise SmokeError(
+ f"Runtime stack-cost probe returned invalid regression data: {probes}"
+ ) from error
+ if ordered_r_squared[1] >= 0.5:
+ raise SmokeError(
+ "Runtime.enable exposed a repeatable Error stack-depth timing slope: "
+ f"{probes}"
+ )
+ return {
+ "probes": probes,
+ "medianRSquared": ordered_r_squared[1],
+ }
+
+
async def run_file_chooser_group(
endpoint: str,
fixture: str,
diff --git a/moli-cdp-smoke/moli_cdp_smoke/runner.py b/moli-cdp-smoke/moli_cdp_smoke/runner.py
index 660fbe4e4..e161ec874 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/runner.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/runner.py
@@ -115,7 +115,7 @@ RAW_GROUPS: tuple[SmokeGroup, ...] = (
),
SmokeGroup(
"runtime-exception",
- "Raw asynchronous Runtime.exceptionThrown delivery without a follow-up command.",
+ "Raw Runtime.enable stack-cost privacy and asynchronous Runtime.exceptionThrown delivery.",
"raw",
run_runtime_exception_group,
),
diff --git a/moli-renderer-v8/src/inspector_session.rs b/moli-renderer-v8/src/inspector_session.rs
new file mode 100644
index 000000000..01db1d5c7
--- /dev/null
+++ b/moli-renderer-v8/src/inspector_session.rs
@@ -0,0 +1,80 @@
+//! Synchronous Inspector session commands shared by Page and Worker owners.
+//!
+//! V8 enables Runtime with a 200-frame exception capture limit. Use a ten-frame
+//! default to bound the extra cost of constructing Error objects, while leaving
+//! explicit frontend limits and restored session settings under V8's control.
+
+use serde::Deserialize;
+use serde_json::{Value, json};
+
+const STACK_CAPTURE_CALL_ID: i32 = -1;
+const DEFAULT_RUNTIME_STACK_CAPTURE_DEPTH: i32 = 10;
+
+#[cfg(test)]
+pub(crate) mod tests;
+
+/// Adapts the owner's response routing without changing its notification stream.
+pub(crate) trait InspectorSessionOutput {
+ /// Only for synchronous, non-reentrant Inspector settings. Capture this
+ /// dispatch's response before frontend routing, even if a frontend uses the
+ /// same ID. Preserve queued responses, callbacks, and notifications.
+ fn capture_internal_response(&self, call_id: i32, dispatch: impl FnOnce()) -> Option<Value>;
+}
+
+/// The caller establishes its usual Inspector isolate/microtask scope.
+pub(crate) fn dispatch_with_runtime_defaults(
+ session: &v8::inspector::V8InspectorSession,
+ raw_json: &str,
+ output: &impl InspectorSessionOutput,
+) -> Result<(), String> {
+ let enabling_runtime = serde_json::from_str::<Value>(raw_json).is_ok_and(|message| {
+ message.get("method").and_then(Value::as_str) == Some("Runtime.enable")
+ });
+ let runtime_was_disabled = enabling_runtime && !runtime_enabled(session)?;
+ session.dispatch_protocol_message(v8::inspector::StringView::from(raw_json.as_bytes()));
+
+ // V8 owns enable/restore state. Repeated or failed enables must not reset
+ // explicit frontend limits. The setter runs synchronously without JS or
+ // microtasks, so a scoped response capture can safely reuse a fixed ID.
+ if runtime_was_disabled && runtime_enabled(session)? {
+ let request = json!({
+ "id": STACK_CAPTURE_CALL_ID,
+ "method": "Runtime.setMaxCallStackSizeToCapture",
+ "params": {"size": DEFAULT_RUNTIME_STACK_CAPTURE_DEPTH}
+ })
+ .to_string();
+ let response = output
+ .capture_internal_response(STACK_CAPTURE_CALL_ID, || {
+ session
+ .dispatch_protocol_message(v8::inspector::StringView::from(request.as_bytes()));
+ })
+ .ok_or("Runtime stack-capture default produced no Inspector response")?;
+ if response != json!({"id": STACK_CAPTURE_CALL_ID, "result": {}}) {
+ return Err(format!(
+ "Runtime stack-capture default returned an unexpected response: {response}"
+ ));
+ }
+ }
+ Ok(())
+}
+
+fn runtime_enabled(session: &v8::inspector::V8InspectorSession) -> Result<bool, String> {
+ // V8 owns this serialized state and uses these same fields on reconnect.
+ // Decode it only for Runtime.enable, never on the Runtime.evaluate hot path.
+ #[derive(Deserialize)]
+ struct SessionState {
+ #[serde(rename = "Runtime")]
+ runtime: RuntimeState,
+ }
+ #[derive(Deserialize)]
+ struct RuntimeState {
+ #[serde(default, rename = "runtimeEnabled")]
+ enabled: bool,
+ }
+
+ let state = v8::crdtp::cbor_to_json(&session.state())
+ .ok_or("Inspector session state is not valid CBOR")?;
+ let state: SessionState = serde_json::from_slice(&state)
+ .map_err(|error| format!("invalid Inspector Runtime state: {error}"))?;
+ Ok(state.runtime.enabled)
+}
diff --git a/moli-renderer-v8/src/inspector_session/tests.rs b/moli-renderer-v8/src/inspector_session/tests.rs
new file mode 100644
index 000000000..ca90bee38
--- /dev/null
+++ b/moli-renderer-v8/src/inspector_session/tests.rs
@@ -0,0 +1,103 @@
+use serde_json::{Value, json};
+
+fn stack_probe() -> String {
+ json!({
+ "id": 100,
+ "method": "Runtime.evaluate",
+ "params": {
+ "expression": "(function recurse(n) { if (n) return recurse(n - 1); throw new Error('stack depth'); })(80)"
+ }
+ })
+ .to_string()
+}
+
+fn assert_frontend_response(messages: &[Value], request: &Value) {
+ let responses = messages
+ .iter()
+ .filter(|message| message.get("id").is_some())
+ .collect::<Vec<_>>();
+ assert_eq!(
+ responses,
+ vec![&json!({"id": request["id"], "result": {}})],
+ "only the frontend response may escape, including when its ID is negative: {request}"
+ );
+}
+
+fn assert_stack_depth(messages: &[Value], expected: usize, request: &Value) {
+ let response = messages
+ .iter()
+ .find(|message| message["id"] == json!(100))
+ .expect("stack probe response");
+ let exception = &response["result"]["exceptionDetails"];
+ assert!(exception.is_object(), "probe must throw: {response}");
+ let depth = exception["stackTrace"]["callFrames"]
+ .as_array()
+ .map_or(0, Vec::len);
+ assert_eq!(
+ depth, expected,
+ "Inspector exception stack depth after {request}: {response}"
+ );
+}
+
+pub(crate) fn assert_session_lifecycle(mut dispatch: impl FnMut(&str) -> Vec<Value>) {
+ for request in [
+ json!({"id": 9, "method": "Runtime.enable", "params": "invalid"}),
+ json!({"id": 9, "method": "Runtime.setMaxCallStackSizeToCapture", "params": {"size": 50}}),
+ ] {
+ let messages = dispatch(&request.to_string());
+ assert!(
+ messages
+ .iter()
+ .any(|message| message["id"] == json!(9) && message.get("error").is_some()),
+ "failed requests must retain their protocol error and must not enable Runtime: {messages:?}"
+ );
+ }
+ let probe = stack_probe();
+ for (request, expected_depth) in [
+ (json!({"id": -1, "method": "Runtime.enable"}), Some(10)),
+ (
+ json!({"id": 2, "method": "Runtime.setMaxCallStackSizeToCapture", "params": {"size": 50}}),
+ Some(50),
+ ),
+ (json!({"id": -1, "method": "Runtime.enable"}), Some(50)),
+ (
+ json!({"id": 3, "method": "Runtime.setMaxCallStackSizeToCapture", "params": {"size": 0}}),
+ Some(0),
+ ),
+ (json!({"id": -1, "method": "Runtime.enable"}), Some(0)),
+ (json!({"id": 4, "method": "Runtime.disable"}), None),
+ (json!({"id": -1, "method": "Runtime.enable"}), Some(10)),
+ ] {
+ assert_frontend_response(&dispatch(&request.to_string()), &request);
+ if let Some(expected_depth) = expected_depth {
+ assert_stack_depth(&dispatch(&probe), expected_depth, &request);
+ }
+ }
+}
+
+pub(crate) fn assert_multiple_sessions(mut dispatch: impl FnMut(&str, &str) -> Vec<Value>) {
+ let probe = stack_probe();
+ for (session, request, expected_depth) in [
+ ("A", json!({"id": -1, "method": "Runtime.enable"}), Some(10)),
+ (
+ "A",
+ json!({"id": 2, "method": "Runtime.setMaxCallStackSizeToCapture", "params": {"size": 50}}),
+ Some(50),
+ ),
+ ("B", json!({"id": -1, "method": "Runtime.enable"}), Some(50)),
+ ("A", json!({"id": -1, "method": "Runtime.enable"}), Some(50)),
+ ("A", json!({"id": 3, "method": "Runtime.disable"}), Some(10)),
+ (
+ "B",
+ json!({"id": 4, "method": "Runtime.setMaxCallStackSizeToCapture", "params": {"size": 0}}),
+ Some(0),
+ ),
+ ("B", json!({"id": -1, "method": "Runtime.enable"}), Some(0)),
+ ("B", json!({"id": 5, "method": "Runtime.disable"}), None),
+ ] {
+ assert_frontend_response(&dispatch(session, &request.to_string()), &request);
+ if let Some(expected_depth) = expected_depth {
+ assert_stack_depth(&dispatch(session, &probe), expected_depth, &request);
+ }
+ }
+}
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index d46ca79f5..e8fc5a3d8 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -57,6 +57,7 @@ mod frame_owner_model;
mod host;
mod host_bindings;
mod inspector_microtasks;
+mod inspector_session;
mod javascript_url;
mod layout_renderer;
mod link_as;
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs b/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
index f4800607e..50b171827 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/lifecycle.rs
@@ -10,7 +10,7 @@ use crate::{
RendererDocumentLifecycleEventKind, RendererDocumentLifecycleIdentity,
RendererDocumentLifecycleMilestone, RendererDocumentLifecycleWaitOutcome,
RendererDocumentTerminationReason, RendererLifecycleStartReason, RendererPageReply,
- RendererPageState,
+ RendererPageState, RendererRuntimeInspectorMessage,
page_task_queue::PostParseLifecycleWork,
runtime::document_lifecycle_turn::DocumentLifecycleNavigationTiming,
script_vm::{
@@ -20,6 +20,7 @@ use crate::{
MainDocumentLifecycleTargetRejection,
},
};
+use serde_json::Value;
use std::sync::Arc;
#[test]
@@ -3654,6 +3655,69 @@ fn runtime_evaluate_without_enable_uses_inspector_default_context() {
);
}
+#[test]
+fn runtime_stack_capture_follows_session_lifecycle() {
+ let mut page_vm = test_page_vm();
+ crate::inspector_session::tests::assert_session_lifecycle(|request| {
+ page_vm
+ .vm_mut()
+ .dispatch_inspector_protocol_message(request)
+ .expect("Page Inspector dispatch")
+ });
+}
+
+#[test]
+fn runtime_stack_capture_preserves_independent_session_limits() {
+ let mut page_vm = test_page_vm();
+ crate::inspector_session::tests::assert_multiple_sessions(|session, request| {
+ page_vm
+ .vm_mut()
+ .dispatch_inspector_protocol_message_for_session(Some(session), request)
+ .expect("Page Inspector session dispatch")
+ .into_iter()
+ .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
+ .collect()
+ });
+}
+
+#[test]
+fn runtime_enable_hides_the_internal_stack_capture_limit_response() {
+ let mut page_vm = test_page_vm();
+
+ let messages = page_vm
+ .vm_mut()
+ .dispatch_inspector_protocol_message(r#"{"id":41,"method":"Runtime.enable"}"#)
+ .expect("Runtime.enable dispatch");
+ assert!(
+ messages
+ .iter()
+ .any(|message| message["id"] == json!(41) && message["result"] == json!({})),
+ "Runtime.enable should retain its frontend response: {messages:#?}"
+ );
+ assert!(
+ messages.iter().all(|message| {
+ message
+ .get("id")
+ .and_then(Value::as_i64)
+ .is_none_or(|call_id| call_id >= 0)
+ }),
+ "the private stack-capture command response must not enter Page CDP output: {messages:#?}"
+ );
+
+ let messages = page_vm
+ .vm_mut()
+ .dispatch_inspector_protocol_message(
+ r#"{"id":42,"method":"Runtime.setMaxCallStackSizeToCapture","params":{"size":8}}"#,
+ )
+ .expect("frontend Page stack-capture command");
+ assert!(
+ messages
+ .iter()
+ .any(|message| message["id"] == json!(42) && message["result"] == json!({})),
+ "the private default must not prevent a frontend override: {messages:#?}"
+ );
+}
+
#[test]
fn page_diagnostics_snapshot_uses_rust_runtime_observable_console_source_queue() {
let mut page_vm = test_page_vm();
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 346dc071a..e371754ca 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -18,6 +18,7 @@ use crate::{
FrameRealmId, FrameScriptJob, FrameScriptJobKind,
},
inspector_microtasks::with_scoped_inspector_microtasks,
+ inspector_session::dispatch_with_runtime_defaults,
network::{ResourceRequestClient, context::DocumentResourceLoader},
page_task_queue::{
PageRuntimeWakeSender, PageTask, PageTaskSender, PostParseLifecycleWork,
@@ -1535,10 +1536,9 @@ impl ScriptVm {
let _dispatch_response_capture =
outbound.capture_dispatch_responses();
with_scoped_inspector_microtasks(scope, || {
- session.dispatch_protocol_message(
- v8::inspector::StringView::from(raw_json.as_bytes()),
- );
- });
+ dispatch_with_runtime_defaults(session, raw_json, &outbound)
+ })
+ .map_err(anyhow::Error::msg)?;
}
let response = outbound
.take_response_for_call_id_after(
@@ -1762,11 +1762,12 @@ impl ScriptVm {
// callback even if they settle in this same owner turn.
let dispatch_response_capture = outbound.capture_dispatch_responses();
let dispatch_started = timing_started.map(|_| Instant::now());
- with_scoped_inspector_microtasks(scope, || {
- session.dispatch_protocol_message(v8::inspector::StringView::from(
- raw_json.as_bytes(),
- ));
- });
+ if let Err(error) = with_scoped_inspector_microtasks(scope, || {
+ dispatch_with_runtime_defaults(session, raw_json, &outbound)
+ }) {
+ outbound.discard_messages_after(snap);
+ return Err(anyhow::Error::msg(error));
+ }
if let (Some(total_started), Some(started)) =
(timing_started, dispatch_started)
{
diff --git a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
index 46c0435d6..b8f966139 100644
--- a/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/agent_sessions.rs
@@ -410,6 +410,7 @@ pub(super) fn inspector_session_key(inspector_session_id: Option<&str>) -> DevTo
#[cfg(test)]
mod tests {
use super::*;
+ use crate::inspector_session::dispatch_with_runtime_defaults;
use crate::script_vm::inspector::context_registry::DocumentInspectorContextRegistrationId;
use serde_json::Value;
use std::pin::pin;
@@ -423,9 +424,8 @@ mod tests {
fn dispatch(session: &RendererDevToolsSession, request: &str) -> Vec<Value> {
let snapshot = session.outbound.len();
let _response_capture = session.outbound.capture_dispatch_responses();
- session
- .session
- .dispatch_protocol_message(v8::inspector::StringView::from(request.as_bytes()));
+ dispatch_with_runtime_defaults(&session.session, request, &session.outbound)
+ .expect("Inspector session dispatch");
session.outbound.take_messages_after(snapshot)
}
@@ -587,6 +587,14 @@ mod tests {
4,
);
+ assert_successful_response(
+ &dispatch(
+ &first_attach,
+ r#"{"id":6,"method":"Runtime.setMaxCallStackSizeToCapture","params":{"size":50}}"#,
+ ),
+ 6,
+ );
+
let state = first_attach.v8_state();
assert!(
!state.is_empty(),
@@ -658,6 +666,15 @@ mod tests {
"V8 should apply the restored custom formatter setting: {formatter_response:?}"
);
let restored_state = restored.v8_state();
+ assert_successful_response(
+ &dispatch(&restored, r#"{"id":7,"method":"Runtime.enable"}"#),
+ 7,
+ );
+ assert_eq!(
+ state_json(&restored.v8_state()),
+ state_json(&restored_state),
+ "repeated Runtime.enable must preserve the restored stack-capture override"
+ );
assert_eq!(
state_json(&restored_state),
initial_state_json,
diff --git a/moli-renderer-v8/src/script_vm/inspector/outbound.rs b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
index 28cef9383..97a519c78 100644
--- a/moli-renderer-v8/src/script_vm/inspector/outbound.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/outbound.rs
@@ -2,6 +2,7 @@ use crate::devtools::pause::{
RendererInspectorPauseNotificationRoute, RendererInspectorPausePrefaceGuard,
RendererInspectorSessionOutboundRoute,
};
+use crate::inspector_session::InspectorSessionOutput;
use crate::runtime::{
PendingRendererOutputRecord, RendererCommandTurnOutputRecorder,
RendererDevToolsSessionOutputHost, RendererProtocolObservation,
@@ -76,6 +77,18 @@ impl Default for InspectorOutbound {
}
}
+impl InspectorSessionOutput for InspectorOutbound {
+ fn capture_internal_response(&self, call_id: i32, dispatch: impl FnOnce()) -> Option<Value> {
+ let snapshot = self.len();
+ {
+ let _internal_capture = self.capture_internal_dispatch_response(call_id);
+ let _dispatch_capture = self.capture_dispatch_responses();
+ dispatch();
+ }
+ self.take_response_for_call_id_after(snapshot, i64::from(call_id))
+ }
+}
+
impl InspectorOutbound {
pub(super) fn for_agent(agent_token: RendererDevToolsAgentToken) -> Self {
Self {
@@ -337,9 +350,6 @@ impl InspectorOutbound {
}
pub(super) fn push_response_value(&self, call_id: i32, value: Value) {
- if let Some(session_route) = self.session_route.borrow().as_ref() {
- session_route.mark_command_response(call_id, value.get("error").is_none());
- }
let mut guard = self.response_routing.borrow_mut();
if guard
.internal_dispatch_response_call_ids
@@ -350,6 +360,9 @@ impl InspectorOutbound {
self.push_local_value(value);
return;
}
+ if let Some(session_route) = self.session_route.borrow().as_ref() {
+ session_route.mark_command_response(call_id, value.get("error").is_none());
+ }
let callback = guard.pending_response_callbacks.remove(&call_id);
if let Some(callback) = callback {
let recorder = (guard.runtime_command_output_suppression_depth == 0)
@@ -548,6 +561,8 @@ impl InspectorOutbound {
.map(|message| message.value)
}
+ // DOMDebugger's internal Runtime.callFunctionOn can execute JS, unlike the
+ // synchronous stack-capture setter, so it still needs an unoccupied ID.
pub(in crate::script_vm) fn internal_dispatch_call_id_is_available(
&self,
call_id: i32,
@@ -751,14 +766,21 @@ impl Drop for InspectorInternalDispatchResponseCapture {
#[cfg(test)]
mod tests {
use super::*;
- use crate::runtime::{PageId, RendererOutputItem, RendererOutputStreamIdentity};
-
- #[test]
- fn instrumentation_pause_prefix_publishes_context_created_with_bound_origin() {
+ use crate::devtools::pause::RendererInspectorPauseBridge;
+ use crate::runtime::{
+ PageId, RendererInspectorCommandRoute, RendererInspectorIngressTicket,
+ RendererInspectorPauseCommandEffect, RendererOutputItem, RendererOutputStreamIdentity,
+ };
+
+ fn routed_outbound() -> (
+ InspectorOutbound,
+ RendererInspectorPauseBridge,
+ RendererTurnOutputJournal,
+ ) {
let journal = RendererTurnOutputJournal::new(
RendererOutputStreamIdentity::new_page_for_protocol_test(PageId::new_for_testing(41)),
);
- let pause_bridge = crate::devtools::pause::RendererInspectorPauseBridge::default();
+ let pause_bridge = RendererInspectorPauseBridge::default();
pause_bridge.configure_page_route(journal.clone());
let agent_token = RendererDevToolsAgentToken::allocate();
let session = DevToolsSessionKey::Primary;
@@ -781,9 +803,63 @@ mod tests {
.outbound_route(agent_token, session.clone()),
Some(journal.clone()),
);
+ (outbound, pause_bridge, journal)
+ }
+
+ #[test]
+ fn internal_response_does_not_complete_a_same_id_frontend_pause_command() {
+ let (outbound, bridge, _) = routed_outbound();
+ let route = outbound
+ .session_route
+ .borrow()
+ .clone()
+ .expect("frontend route");
+ route.route_notification(&serde_json::json!({
+ "method": "Debugger.paused", "params": {"callFrames": []}
+ }));
+ assert!(bridge.enter_pause().is_some());
+ let dispatch = bridge.begin_command_dispatch(
+ 1,
+ &RendererInspectorIngressTicket::new(None, None, RendererInspectorCommandRoute::Io),
+ RendererInspectorPauseCommandEffect::Resume,
+ Some(-1),
+ );
+ let recorder = RendererCommandTurnOutputRecorder::default();
+ outbound
+ .begin_command_turn_output(DevToolsSessionKey::Primary, recorder.clone())
+ .expect("command output scope");
+ let response = serde_json::json!({"id": -1, "result": {}});
+ assert_eq!(
+ outbound.capture_internal_response(-1, || {
+ outbound.push_response_value(-1, response.clone());
+ }),
+ Some(response)
+ );
+ outbound.end_command_turn_output(&recorder);
+ assert!(recorder.finish().is_empty());
+ assert!(outbound.take_pending_messages().is_empty());
+ drop(dispatch);
+ bridge.leave_pause();
+ assert!(
+ matches!(
+ route.route_notification(
+ &serde_json::json!({"method": "Debugger.resumed", "params": {}})
+ ),
+ RendererInspectorPauseNotificationRoute::PublishImmediately {
+ command_output: None,
+ ..
+ }
+ ),
+ "the internal response must not mark the frontend resume command successful"
+ );
+ }
+
+ #[test]
+ fn instrumentation_pause_prefix_publishes_context_created_with_bound_origin() {
+ let (outbound, pause_bridge, journal) = routed_outbound();
let recorder = RendererCommandTurnOutputRecorder::default();
outbound
- .begin_command_turn_output(session, recorder)
+ .begin_command_turn_output(DevToolsSessionKey::Primary, recorder)
.expect("command output scope");
outbound.push_value(serde_json::json!({
diff --git a/moli-renderer-v8/src/script_vm/inspector/tests.rs b/moli-renderer-v8/src/script_vm/inspector/tests.rs
index 3bba50d23..aff847ffd 100644
--- a/moli-renderer-v8/src/script_vm/inspector/tests.rs
+++ b/moli-renderer-v8/src/script_vm/inspector/tests.rs
@@ -1,4 +1,5 @@
use super::*;
+use crate::inspector_session::InspectorSessionOutput;
#[test]
fn inspector_outbound_queue_reports_its_exact_length_until_flushed() {
@@ -325,6 +326,31 @@ fn internal_dispatch_call_id_avoids_queued_and_active_frontend_ids() {
assert!(outbound.internal_dispatch_call_id_is_available(-2));
}
+#[test]
+fn internal_response_capture_preserves_queued_responses_and_canceled_callbacks() {
+ let outbound = InspectorOutbound::default();
+ let queued = json!({"id": -1, "result": "queued"});
+ let notification = json!({"method": "Runtime.consoleAPICalled", "params": {}});
+ outbound.push_value(queued.clone());
+ let (tx, _rx) = tokio::sync::oneshot::channel();
+ outbound.register_response_callback(RendererRuntimeInspectorResponseSender::new(-1, tx));
+ outbound.cancel_response_callback(-1);
+
+ let response = outbound.capture_internal_response(-1, || {
+ outbound.push_response_value(-1, json!({"id": -1, "result": "outer"}));
+ let nested = outbound.capture_internal_response(-1, || {
+ outbound.push_value(notification.clone());
+ outbound.push_response_value(-1, json!({"id": -1, "result": "inner"}));
+ });
+ assert_eq!(nested, Some(json!({"id": -1, "result": "inner"})));
+ });
+ assert_eq!(response, Some(json!({"id": -1, "result": "outer"})));
+ assert_eq!(outbound.response_callback_counts(), (0, 1));
+ outbound.push_response_value(-1, json!({"id": -1, "result": "canceled"}));
+ assert_eq!(outbound.response_callback_counts(), (0, 0));
+ assert_eq!(outbound.take_pending_messages(), vec![queued, notification]);
+}
+
#[test]
fn document_inspector_context_group_ids_are_unique() {
let first = DocumentInspectorContextGroupId::next();
diff --git a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
index b53cbcbba..398dfe57b 100644
--- a/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
+++ b/moli-renderer-v8/src/worker/thread/runtime_inspector.rs
@@ -7,6 +7,7 @@ use std::{
use serde_json::{Value, json};
use crate::inspector_microtasks::with_scoped_inspector_microtasks;
+use crate::inspector_session::{InspectorSessionOutput, dispatch_with_runtime_defaults};
use crate::runtime::{RendererRuntimeInspectorMessage, RendererRuntimeInspectorResponseSender};
use crate::worker::{
handle::{WorkerRuntimeInspectorMessageBatch, WorkerToParentMessage},
@@ -34,9 +35,34 @@ struct WorkerInspectorOutboundState {
#[derive(Clone, Default)]
struct WorkerInspectorOutbound(Rc<RefCell<WorkerInspectorOutboundState>>);
+struct WorkerInspectorSessionOutput<'a> {
+ outbound: &'a WorkerInspectorOutbound,
+ session_key: &'a str,
+}
+
+impl InspectorSessionOutput for WorkerInspectorSessionOutput<'_> {
+ fn capture_internal_response(&self, call_id: i32, dispatch: impl FnOnce()) -> Option<Value> {
+ let scope = self
+ .outbound
+ .push_dispatch_scope(self.session_key, Some(call_id));
+ dispatch();
+ let mut response = None;
+ for message in scope.finish() {
+ let value = message.into_v8_inspector_message();
+ if value.get("id").and_then(Value::as_i64) == Some(i64::from(call_id)) {
+ response = Some(value);
+ } else {
+ self.outbound.push_value(self.session_key, value);
+ }
+ }
+ response
+ }
+}
+
#[derive(Default)]
struct WorkerInspectorDispatchScope {
session_key: String,
+ internal_call_id: Option<i32>,
messages: Vec<RendererRuntimeInspectorMessage>,
}
@@ -158,13 +184,22 @@ impl WorkerInspectorOutbound {
}
fn push_response_value(&self, session_key: &str, call_id: i32, value: Value) {
- let callback = {
- self.0
- .borrow_mut()
- .pending_response_callbacks
- .remove(&(session_key.to_owned(), call_id))
- };
- if let Some(callback) = callback {
+ let mut guard = self.0.borrow_mut();
+ if let Some(scope) = guard.active_dispatch_scopes.last_mut().filter(|scope| {
+ scope.session_key == session_key && scope.internal_call_id == Some(call_id)
+ }) {
+ scope
+ .messages
+ .push(RendererRuntimeInspectorMessage::from_v8_inspector_message(
+ value,
+ ));
+ return;
+ }
+ if let Some(callback) = guard
+ .pending_response_callbacks
+ .remove(&(session_key.to_owned(), call_id))
+ {
+ drop(guard);
if let Err(message) = callback.send(value) {
tracing::debug!(
call_id,
@@ -174,7 +209,6 @@ impl WorkerInspectorOutbound {
}
return;
}
- let mut guard = self.0.borrow_mut();
if let Some(scope) = guard
.active_dispatch_scopes
.last_mut()
@@ -245,12 +279,17 @@ impl WorkerInspectorOutbound {
coalesce_worker_inspector_messages(messages)
}
- fn push_dispatch_scope(&self, session_key: &str) -> WorkerInspectorDispatchScopeGuard {
+ fn push_dispatch_scope(
+ &self,
+ session_key: &str,
+ internal_call_id: Option<i32>,
+ ) -> WorkerInspectorDispatchScopeGuard {
self.0
.borrow_mut()
.active_dispatch_scopes
.push(WorkerInspectorDispatchScope {
session_key: session_key.to_owned(),
+ internal_call_id,
messages: Vec::new(),
});
WorkerInspectorDispatchScopeGuard {
@@ -510,9 +549,16 @@ impl WorkerRuntimeInspector {
self.outbound
.register_response_callback(&session_key, callback);
}
- let dispatch_scope = self.outbound.push_dispatch_scope(&session_key);
+ let dispatch_scope = self.outbound.push_dispatch_scope(&session_key, None);
let session = self.ensure_session(&session_key);
- session.dispatch_protocol_message(v8::inspector::StringView::from(raw_json.as_bytes()));
+ dispatch_with_runtime_defaults(
+ &session,
+ raw_json,
+ &WorkerInspectorSessionOutput {
+ outbound: &self.outbound,
+ session_key: &session_key,
+ },
+ )?;
let messages = dispatch_scope.finish();
self.record_execution_context_state(&messages);
Ok(messages)
@@ -866,7 +912,7 @@ mod tests {
fn worker_inspector_outbound_captures_dispatch_and_drops_stale_late_response() {
let outbound = WorkerInspectorOutbound::default();
- let dispatch_scope = outbound.push_dispatch_scope("SID-1");
+ let dispatch_scope = outbound.push_dispatch_scope("SID-1", None);
outbound.push_response_value("SID-1", 1, json!({"id": 1, "result": "command-tail"}));
let current = dispatch_scope.finish();
outbound.push_response_value("SID-1", 2, json!({"id": 2, "result": "late"}));
@@ -884,6 +930,192 @@ mod tests {
);
}
+ #[test]
+ fn worker_runtime_enable_hides_the_internal_stack_capture_limit_response() {
+ crate::ensure_v8_for_test();
+ let mut isolate = v8::Isolate::new(Default::default());
+ let inspector = WorkerRuntimeInspector::new_for_test(&mut isolate);
+ let context = {
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let context = v8::Context::new(scope, Default::default());
+ inspector.attach_context(
+ context,
+ v8::Global::new(scope, context),
+ "https://worker-runtime-limit.test/worker.js",
+ );
+ v8::Global::new(scope, context)
+ };
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let context = v8::Local::new(scope, &context);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let (tx, mut rx) = tokio::sync::oneshot::channel();
+ inspector
+ .dispatch_protocol_message_with_optional_deferred_response(
+ scope,
+ None,
+ r#"{"id":-1,"method":"Runtime.evaluate","params":{"expression":"new Promise(resolve => globalThis.resolveStackCaptureProbe = resolve)","awaitPromise":true}}"#,
+ Some(RendererRuntimeInspectorResponseSender::new(-1, tx)),
+ )
+ .expect("pending frontend evaluation before Runtime.enable");
+ let messages = inspector
+ .dispatch_protocol_message(scope, None, r#"{"id":41,"method":"Runtime.enable"}"#)
+ .expect("worker Runtime.enable dispatch");
+ assert_eq!(protocol_response(&messages, 41)["result"], json!({}));
+ assert!(
+ messages.iter().all(|message| match message {
+ RendererRuntimeInspectorMessage::Protocol(message) => message
+ .value()
+ .get("id")
+ .and_then(Value::as_i64)
+ .is_none_or(|call_id| call_id >= 0),
+ RendererRuntimeInspectorMessage::RuntimeContext(_) => true,
+ }),
+ "the private stack-capture command response must not enter worker CDP output: {messages:#?}"
+ );
+ assert!(
+ matches!(
+ rx.try_recv(),
+ Err(tokio::sync::oneshot::error::TryRecvError::Empty)
+ ),
+ "the internal -1 response must not settle the pending frontend -1 command"
+ );
+ inspector.dispatch_protocol_message(
+ scope,
+ None,
+ r#"{"id":40,"method":"Runtime.evaluate","params":{"expression":"resolveStackCaptureProbe(7)"}}"#,
+ ).expect("resolve frontend evaluation");
+ let completion = rx.try_recv().expect("frontend promise response");
+ assert_eq!(
+ completion
+ .output
+ .protocol_response(-1)
+ .expect("response ID -1")["result"]["result"]["value"],
+ json!(7)
+ );
+
+ let messages = inspector
+ .dispatch_protocol_message(
+ scope,
+ None,
+ r#"{"id":42,"method":"Runtime.setMaxCallStackSizeToCapture","params":{"size":8}}"#,
+ )
+ .expect("frontend worker stack-capture command");
+ assert_eq!(
+ protocol_response(&messages, 42)["result"],
+ json!({}),
+ "the private default must not prevent a frontend override"
+ );
+
+ inspector
+ .dispatch_protocol_message(scope, None, r#"{"id":43,"method":"Runtime.disable"}"#)
+ .expect("disable before checking the session lifecycle");
+ crate::inspector_session::tests::assert_session_lifecycle(|request| {
+ inspector
+ .dispatch_protocol_message(scope, None, request)
+ .expect("Worker Inspector dispatch")
+ .into_iter()
+ .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
+ .collect()
+ });
+ inspector
+ .dispatch_protocol_message(scope, None, r#"{"id":44,"method":"Runtime.disable"}"#)
+ .expect("disable the default session before testing independent limits");
+ crate::inspector_session::tests::assert_multiple_sessions(|session, request| {
+ inspector
+ .dispatch_protocol_message(scope, Some(session), request)
+ .expect("Worker Inspector session dispatch")
+ .into_iter()
+ .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)
+ .collect()
+ });
+ }
+
+ #[test]
+ fn worker_internal_response_capture_preserves_frontend_output() {
+ let outbound = WorkerInspectorOutbound::default();
+ let scope = outbound.push_dispatch_scope("SID-1", None);
+ let queued = json!({"id": -1, "result": "queued"});
+ let notification = json!({"method": "Runtime.consoleAPICalled", "params": {}});
+ outbound.push_response_value("SID-1", -1, queued.clone());
+ let (tx, mut rx) = tokio::sync::oneshot::channel();
+ outbound.register_response_callback(
+ "SID-1",
+ RendererRuntimeInspectorResponseSender::new(-1, tx),
+ );
+ let (peer_tx, mut peer_rx) = tokio::sync::oneshot::channel();
+ outbound.register_response_callback(
+ "SID-2",
+ RendererRuntimeInspectorResponseSender::new(-1, peer_tx),
+ );
+ let output = WorkerInspectorSessionOutput {
+ outbound: &outbound,
+ session_key: "SID-1",
+ };
+
+ let response = output.capture_internal_response(-1, || {
+ outbound.push_response_value("SID-1", -1, json!({"id": -1, "result": "outer"}));
+ let nested = output.capture_internal_response(-1, || {
+ outbound.push_response_value("SID-2", -1, json!({"id": -1, "result": "peer"}));
+ outbound.push_value("SID-1", notification.clone());
+ outbound.push_response_value("SID-1", -1, json!({"id": -1, "result": "inner"}));
+ });
+ assert_eq!(nested, Some(json!({"id": -1, "result": "inner"})));
+ });
+ assert_eq!(response, Some(json!({"id": -1, "result": "outer"})));
+ assert_eq!(
+ peer_rx
+ .try_recv()
+ .expect("peer callback must not be intercepted")
+ .output
+ .protocol_response(-1),
+ Some(&json!({"id": -1, "result": "peer"}))
+ );
+ assert!(matches!(
+ rx.try_recv(),
+ Err(tokio::sync::oneshot::error::TryRecvError::Empty)
+ ));
+ outbound.push_response_value("SID-1", -1, json!({"id": -1, "result": "frontend"}));
+ let completion = rx
+ .try_recv()
+ .expect("frontend callback must remain registered");
+ assert_eq!(
+ completion.output.protocol_response(-1),
+ Some(&json!({"id": -1, "result": "frontend"}))
+ );
+ assert_eq!(
+ scope.finish(),
+ vec![inspector_message(queued), inspector_message(notification)]
+ );
+ assert!(outbound.take_all().is_empty());
+ }
+
+ #[test]
+ fn worker_internal_response_capture_restores_routing_after_unwind() {
+ let outbound = WorkerInspectorOutbound::default();
+ let scope = outbound.push_dispatch_scope("SID-1", None);
+ let (tx, mut rx) = tokio::sync::oneshot::channel();
+ outbound.register_response_callback(
+ "SID-1",
+ RendererRuntimeInspectorResponseSender::new(-1, tx),
+ );
+ let output = WorkerInspectorSessionOutput {
+ outbound: &outbound,
+ session_key: "SID-1",
+ };
+ assert!(
+ std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+ output.capture_internal_response(-1, || panic!("test dispatch unwind"));
+ }))
+ .is_err()
+ );
+ outbound.push_response_value("SID-1", -1, json!({"id": -1, "result": {}}));
+ assert!(rx.try_recv().is_ok());
+ assert!(scope.finish().is_empty());
+ }
+
#[test]
fn worker_inspector_outbound_duplicate_response_callback_keeps_existing_callback() {
let outbound = WorkerInspectorOutbound::default();
@@ -952,7 +1184,7 @@ mod tests {
fn worker_inspector_outbound_tags_peer_session_pending_messages() {
let outbound = WorkerInspectorOutbound::default();
- let dispatch_scope = outbound.push_dispatch_scope("SID-1");
+ let dispatch_scope = outbound.push_dispatch_scope("SID-1", None);
outbound.push_value(
"SID-2",
json!({"method": "Runtime.executionContextCreated"}),
@@ -978,7 +1210,7 @@ mod tests {
#[test]
fn worker_pause_flushes_active_notifications_but_retains_command_response() {
let outbound = WorkerInspectorOutbound::default();
- let dispatch_scope = outbound.push_dispatch_scope("SID-1");
+ let dispatch_scope = outbound.push_dispatch_scope("SID-1", None);
outbound.push_value("SID-1", json!({"method": "Debugger.paused", "params": {}}));
outbound.push_response_value("SID-1", 7, json!({"id": 7, "result": {}}));