Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use super::*;
impl CdpConnection {
pub async fn evaluate_runtime_expression_with_await_async(
&mut self,
expression: &str,
await_promise: bool,
) -> Result<Value, String> {
self.evaluate_runtime_expression_with_await_for_session_owner_async(
None,
expression,
await_promise,
)
.await
}
#[cfg(test)]
pub(crate) async fn evaluate_runtime_expression_for_session_owner_async(
&mut self,
session_id: Option<&str>,
expression: &str,
) -> Result<Value, String> {
self.evaluate_runtime_expression_with_await_for_session_owner_async(
session_id, expression, false,
)
.await
}
pub(crate) async fn evaluate_runtime_expression_with_await_for_session_owner_async(
&mut self,
session_id: Option<&str>,
expression: &str,
await_promise: bool,
) -> Result<Value, String> {
self.evaluate_runtime_expression_for_session_owner_once_async(
session_id,
expression,
await_promise,
)
.await
}
pub(super) async fn evaluate_runtime_expression_for_session_owner_once_async(
&mut self,
session_id: Option<&str>,
expression: &str,
await_promise: bool,
) -> Result<Value, String> {
let payload = {
let page = self.loaded_page_mut_for_protocol_access(session_id)?;
page.evaluate_runtime_expression_without_navigation_follow_with_await_async(
expression,
await_promise,
)
.await
.map_err(|error| format!("runtime evaluation failed: {error}"))?
};
self.ingest_runtime_session_owner_output_updates(session_id);
Ok(payload)
}
#[cfg(test)]
pub async fn dispatch_runtime_protocol_message_async(
&mut self,
raw_json: &str,
) -> Result<Vec<Value>, String> {
self.dispatch_runtime_protocol_message_for_session_owner_async(None, raw_json)
.await
}
pub(crate) fn start_runtime_enable_events_for_owner(
&mut self,
owner: &CommandOwnerScope,
) -> Result<PendingRuntimeEnableEventsDispatch, String> {
let route = self
.runtime_protocol_message_page_route_for_owner(owner)
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
let inspector_session_id =
self.target_renderer_runtime_inspector_session_id_for_owner(owner);
let page = self.loaded_page_mut_for_protocol_access_for_owner(owner)?;
let pending = page
.start_runtime_enable_events_for_inspector_session(inspector_session_id.as_deref())
.map_err(|error| format!("runtime enable event replay failed: {error}"))?;
Ok(PendingRuntimeEnableEventsDispatch {
owner: owner.clone(),
route,
pending,
})
}
pub(crate) fn complete_runtime_enable_events(
&mut self,
completed: CompletedRuntimeEnableEventsDispatch,
) -> Result<RuntimeEnableEventsReplay, String> {
let owner = completed.owner;
let page = self.runtime_protocol_message_started_page_mut(&completed.route)?;
let output = page
.finish_runtime_enable_output(completed.completion)
.map_err(|error| format!("runtime enable event replay failed: {error}"))?;
let attachment_id = output.renderer_agent_attachment_id();
if attachment_id != Some(completed.route.renderer_agent_attachment_id) {
return Err(
"Runtime.enable completed from an unexpected renderer attachment".to_owned(),
);
}
self.prepare_runtime_subscription_events_for_owner(&owner, output)
}
/// Project the frozen replay from either an internal completion or an
/// ordered frontend terminal. The caller has validated the exact attachment.
pub(crate) fn prepare_runtime_subscription_events_for_owner(
&mut self,
owner: &CommandOwnerScope,
output: RendererRuntimeCommandOutput,
) -> Result<RuntimeEnableEventsReplay, String> {
let _ = self.set_renderer_runtime_agent_owns_page_console_api_events_for_owner(owner, true);
self.prepare_runtime_command_events_for_owner(owner, output)
}
pub(crate) fn prepare_runtime_command_events_for_owner(
&mut self,
owner: &CommandOwnerScope,
output: RendererRuntimeCommandOutput,
) -> Result<RuntimeEnableEventsReplay, String> {
let session_id = owner.session_id();
let (_, v8_state_update, messages) = output.into_parts();
if let Some(state) = v8_state_update
&& !self.merge_v8_inspector_session_state_for_owner(owner, state)
{
return Err("Runtime.enable completed after session owner disappeared".to_owned());
}
let mut replay = RuntimeEnableEventsReplay::from_renderer_messages(messages);
self.ingest_runtime_session_owner_output_updates_for_owner(owner);
for event in replay.events_mut() {
match event {
RuntimeEnableReplayEvent::Context(event) => {
qualify_runtime_context_protocol_event_for_owner_typed(self, event, owner);
}
RuntimeEnableReplayEvent::Background(event) => {
event.ensure_protocol_session_id(session_id);
}
}
}
Ok(replay)
}
pub(super) fn runtime_protocol_message_page_route_for_owner(
&self,
owner: &CommandOwnerScope,
) -> Option<RuntimeProtocolMessagePageRoute> {
let (browser_context_id, target_id) = self.target_owner_identity_for_owner(owner)?;
let slot = self.runtime_session_owner_slot_for_owner(owner)?;
let renderer_agent_attachment_id = slot.current_renderer_attachment()?.id();
Some(RuntimeProtocolMessagePageRoute {
browser_context_id,
target_id,
renderer_agent_attachment_id,
})
}
pub(super) fn runtime_protocol_message_started_slot_mut(
&mut self,
route: &RuntimeProtocolMessagePageRoute,
) -> Result<&mut TargetRuntimeSlot, String> {
let browser_context = self
.browser_context_by_id_mut(&route.browser_context_id)
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
let slot = if browser_context.active_target_id() == route.target_id.as_deref() {
&mut browser_context.active_page_target_mut().runtime_slot
} else {
let target_id = route
.target_id
.as_deref()
.ok_or_else(|| "NoDocumentLoaded".to_owned())?;
browser_context
.background_target_mut(target_id)
.map(|target| &mut target.runtime_slot)
.ok_or_else(|| "NoDocumentLoaded".to_owned())?
};
if slot
.current_renderer_attachment()
.map(|attachment| attachment.id())
!= Some(route.renderer_agent_attachment_id)
{
return Err("Renderer attachment changed".to_owned());
}
Ok(slot)
}
pub(super) fn runtime_protocol_message_started_page_mut(
&mut self,
route: &RuntimeProtocolMessagePageRoute,
) -> Result<&mut Page, String> {
self.runtime_protocol_message_started_slot_mut(route)?
.loaded_page_mut()
.ok_or_else(|| "NoDocumentLoaded".to_owned())
}
pub(super) fn consume_runtime_protocol_message_completion(
&mut self,
route: &RuntimeProtocolMessagePageRoute,
completion: moli_core::page::CompletedPageCommand,
) -> Result<RendererCommandTurnOutput, String> {
let output = if let Ok(page) = self.runtime_protocol_message_started_page_mut(route) {
page.finish_runtime_protocol_message_command_turn(completion)
} else {
// Completion means the renderer owner has already committed the
// command's Page state and concrete protocol publication. The
// target can install a successor attachment before this protocol
// task resumes (for example, form.submit() followed by a normal
// command response). Preserve that immutable result; there is
// simply no current Page cache belonging to this route to update.
completion.into_runtime_protocol_message_command_turn()
};
output.map_err(|error| format!("runtime inspector dispatch failed: {error}"))
}
pub(super) fn ingest_runtime_protocol_message_started_route_output_updates(
&mut self,
route: &RuntimeProtocolMessagePageRoute,
) {
if let Ok(slot) = self.runtime_protocol_message_started_slot_mut(route) {
let _ = slot.ingest_owner_page_observable_output_updates();
}
}
pub(super) fn shared_worker_runtime_target_for_session(
&self,
session_id: Option<&str>,
) -> Result<SharedWorkerRuntimeTargetRoute, String> {
let session_id = session_id.ok_or_else(|| "UnknownSession".to_owned())?;
let route = self
.session_route(Some(session_id))
.ok_or_else(|| "UnknownSession".to_owned())?;
match route {
CdpSessionRoute::SharedWorkerTarget {
browser_context_id,
target_id,
} => {
let target = self
.browser_context_by_id(&browser_context_id)
.and_then(|context| context.shared_worker_target(&target_id))
.ok_or_else(|| "UnknownSession".to_owned())?;
Ok(SharedWorkerRuntimeTargetRoute {
browser_context_id,
worker: WorkerRuntimeTarget::Shared(target.renderer_instance_id),
})
}
CdpSessionRoute::DedicatedWorkerTarget {
browser_context_id,
target_id,
} => {
let target = self
.browser_context_by_id(&browser_context_id)
.and_then(|context| context.dedicated_worker_target(&target_id))
.ok_or_else(|| "UnknownSession".to_owned())?;
Ok(SharedWorkerRuntimeTargetRoute {
browser_context_id,
worker: WorkerRuntimeTarget::Dedicated(target.renderer_instance_id),
})
}
_ => Err("UnknownSession".to_owned()),
}
}
pub(crate) fn run_dedicated_worker_if_waiting_for_debugger_for_session(
&mut self,
session_id: Option<&str>,
) -> Result<bool, String> {
let session_id = session_id.ok_or_else(|| "UnknownSession".to_owned())?;
let route = self.shared_worker_runtime_target_for_session(Some(session_id))?;
let WorkerRuntimeTarget::Dedicated(instance_id) = route.worker else {
return Ok(false);
};
if let Some(target) = self.dedicated_worker_target_for_session_mut(Some(session_id)) {
target.discard_main_script_network_replay_for(session_id);
}
let renderer_runtime = self
.browser_context_by_id(&route.browser_context_id)
.map(|context| context.renderer_runtime())
.ok_or_else(|| "UnknownSession".to_owned())?;
Ok(renderer_runtime.run_dedicated_worker_if_waiting_for_debugger_for_devtools(instance_id))
}
pub(super) fn service_worker_runtime_target_for_session(
&self,
session_id: Option<&str>,
) -> Result<ServiceWorkerRuntimeTargetRoute, String> {
let session_id = session_id.ok_or_else(|| "UnknownSession".to_owned())?;
let CdpSessionRoute::ServiceWorkerTarget {
browser_context_id,
target_id,
} = self
.session_route(Some(session_id))
.ok_or_else(|| "UnknownSession".to_owned())?
else {
return Err("UnknownSession".to_owned());
};
let target = self
.browser_context_by_id(&browser_context_id)
.and_then(|context| context.service_worker_target(&target_id))
.ok_or_else(|| "UnknownSession".to_owned())?;
Ok(ServiceWorkerRuntimeTargetRoute {
browser_context_id,
version_id: target.renderer_version_id,
})
}
pub(crate) fn start_shared_worker_runtime_protocol_message_for_session(
&mut self,
session_id: Option<&str>,
raw_json: String,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
let raw_json =
self.rewrite_runtime_inspector_command_for_session_owner(session_id, &raw_json, None)?;
self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
None,
RuntimeProtocolResponseRoute::adapter_reply_without_receiver(),
)
}
pub(crate) fn start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(
&mut self,
session_id: Option<&str>,
descriptor: RendererCommandDescriptor,
command_id: u64,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
self.shared_worker_runtime_target_for_session(session_id)?;
let (_correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
self.start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
Some(response_sender),
response_route,
)
}
pub(super) fn start_shared_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
&mut self,
session_id: Option<&str>,
raw_json: String,
response_sender: Option<RendererRuntimeInspectorResponseSender>,
response_route: RuntimeProtocolResponseRoute,
) -> Result<PendingSharedWorkerRuntimeProtocolMessageDispatch, String> {
let route = self.shared_worker_runtime_target_for_session(session_id)?;
let renderer_runtime = self
.browser_context_by_id(&route.browser_context_id)
.map(|context| context.renderer_runtime())
.ok_or_else(|| "UnknownSession".to_owned())?;
let worker = route.worker;
let inspector_session_id = session_id.map(str::to_owned);
let response_delivery = response_route.delivery();
let pending: SharedWorkerRuntimeProtocolDispatchFuture = match (
worker,
response_sender,
response_delivery,
) {
(
WorkerRuntimeTarget::Shared(instance_id),
Some(response),
RendererInspectorResponseDelivery::AdapterReply,
) => Box::pin(async move {
renderer_runtime
.dispatch_shared_worker_runtime_protocol_message_with_deferred_response(
instance_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply)
}),
(
WorkerRuntimeTarget::Shared(instance_id),
Some(response),
RendererInspectorResponseDelivery::SessionSink,
) => {
let inspector_session_id =
inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
Box::pin(async move {
renderer_runtime
.dispatch_shared_worker_runtime_protocol_message_with_devtools_session_response(
instance_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
})
}
(
WorkerRuntimeTarget::Shared(instance_id),
None,
RendererInspectorResponseDelivery::AdapterReply,
) => Box::pin(async move {
renderer_runtime
.dispatch_shared_worker_runtime_protocol_message(
instance_id,
inspector_session_id,
raw_json,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply)
}),
(
WorkerRuntimeTarget::Dedicated(instance_id),
Some(response),
RendererInspectorResponseDelivery::AdapterReply,
) => Box::pin(async move {
renderer_runtime
.dispatch_dedicated_worker_runtime_protocol_message_with_deferred_response(
instance_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply)
}),
(
WorkerRuntimeTarget::Dedicated(instance_id),
Some(response),
RendererInspectorResponseDelivery::SessionSink,
) => {
let inspector_session_id =
inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
Box::pin(async move {
renderer_runtime
.dispatch_dedicated_worker_runtime_protocol_message_with_devtools_session_response(
instance_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
})
}
(
WorkerRuntimeTarget::Dedicated(instance_id),
None,
RendererInspectorResponseDelivery::AdapterReply,
) => Box::pin(async move {
renderer_runtime
.dispatch_dedicated_worker_runtime_protocol_message(
instance_id,
inspector_session_id,
raw_json,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply)
}),
(_, None, RendererInspectorResponseDelivery::SessionSink) => {
return Err("SessionResponseSenderMissing".to_owned());
}
};
Ok(PendingSharedWorkerRuntimeProtocolMessageDispatch {
session_id: session_id.map(str::to_owned),
pending,
response_route,
})
}
pub(crate) async fn dispatch_shared_worker_runtime_helper_protocol_message_for_session_async(
&mut self,
session_id: Option<&str>,
raw_json: &str,
command_id: u64,
) -> anyhow::Result<Vec<RendererRuntimeInspectorMessage>> {
let descriptor = RendererCommandDescriptor::from_synthesized_payload(raw_json.to_owned())
.map_err(anyhow::Error::msg)?;
let pending = self
.start_shared_worker_runtime_protocol_message_for_session_with_deferred_response(
session_id, descriptor, command_id,
)
.map_err(anyhow::Error::msg)?;
let mut completed = pending.wait().await.map_err(anyhow::Error::msg)?;
let response_rx = completed.take_deferred_response_receiver();
let mut messages = self
.complete_shared_worker_runtime_protocol_message_for_session(completed)
.map_err(anyhow::Error::msg)?;
if let Some(response_rx) = response_rx
&& let Some(message) = self
.await_registered_runtime_inspector_response_for_session_owner_async(
session_id,
command_id,
response_rx,
)
.await
{
messages.push(message);
}
Ok(messages)
}
pub(super) async fn dispatch_service_worker_runtime_helper_protocol_message_for_session_async(
&mut self,
session_id: Option<&str>,
raw_json: &str,
command_id: u64,
) -> anyhow::Result<Vec<RendererRuntimeInspectorMessage>> {
let descriptor = RendererCommandDescriptor::from_synthesized_payload(raw_json.to_owned())
.map_err(anyhow::Error::msg)?;
let pending = self
.start_service_worker_runtime_protocol_message_for_session_with_deferred_response(
session_id, descriptor, command_id,
)
.map_err(anyhow::Error::msg)?;
let mut completed = pending.wait().await.map_err(anyhow::Error::msg)?;
let response_rx = completed.take_deferred_response_receiver();
let mut messages = self
.complete_service_worker_runtime_protocol_message_for_session(completed)
.map_err(anyhow::Error::msg)?;
if let Some(response_rx) = response_rx
&& let Some(message) = self
.await_registered_runtime_inspector_response_for_session_owner_async(
session_id,
command_id,
response_rx,
)
.await
{
messages.push(message);
}
Ok(messages)
}
pub(crate) fn complete_shared_worker_runtime_protocol_message_for_session(
&mut self,
mut completed: CompletedSharedWorkerRuntimeProtocolMessageDispatch,
) -> Result<Vec<RendererRuntimeInspectorMessage>, String> {
self.restore_frontend_command_ids_in_runtime_messages(
completed.session_id.as_deref(),
None,
&mut completed.dispatch.messages,
);
Ok(completed.dispatch.messages)
}
pub(crate) fn start_service_worker_runtime_protocol_message_for_session(
&mut self,
session_id: Option<&str>,
raw_json: String,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
let raw_json =
self.rewrite_runtime_inspector_command_for_session_owner(session_id, &raw_json, None)?;
self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
None,
RuntimeProtocolResponseRoute::adapter_reply_without_receiver(),
)
}
pub(crate) fn start_service_worker_runtime_protocol_message_for_session_with_deferred_response(
&mut self,
session_id: Option<&str>,
descriptor: RendererCommandDescriptor,
command_id: u64,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
self.service_worker_runtime_target_for_session(session_id)?;
let (_correlation, raw_json, response_sender, response_route) =
self.prepare_renderer_call_for_session_owner(session_id, descriptor, command_id, None)?;
self.start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
session_id,
raw_json,
Some(response_sender),
response_route,
)
}
pub(super) fn start_service_worker_runtime_protocol_message_for_session_with_optional_deferred_response(
&mut self,
session_id: Option<&str>,
raw_json: String,
response_sender: Option<RendererRuntimeInspectorResponseSender>,
response_route: RuntimeProtocolResponseRoute,
) -> Result<PendingServiceWorkerRuntimeProtocolMessageDispatch, String> {
let route = self.service_worker_runtime_target_for_session(session_id)?;
let renderer_runtime = self
.browser_context_by_id(&route.browser_context_id)
.map(|context| context.renderer_runtime())
.ok_or_else(|| "UnknownSession".to_owned())?;
let version_id = route.version_id;
let inspector_session_id = session_id.map(str::to_owned);
let response_delivery = response_route.delivery();
let pending: ServiceWorkerRuntimeProtocolDispatchFuture = Box::pin(async move {
match (response_sender, response_delivery) {
(Some(response), RendererInspectorResponseDelivery::AdapterReply) => {
renderer_runtime
.dispatch_service_worker_runtime_protocol_message_with_deferred_response(
version_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply)
}
(Some(response), RendererInspectorResponseDelivery::SessionSink) => {
let inspector_session_id =
inspector_session_id.ok_or_else(|| "UnknownSession".to_owned())?;
renderer_runtime
.dispatch_service_worker_runtime_protocol_message_with_devtools_session_response(
version_id,
inspector_session_id,
raw_json,
response,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::devtools_session)
}
(None, RendererInspectorResponseDelivery::AdapterReply) => renderer_runtime
.dispatch_service_worker_runtime_protocol_message(
version_id,
inspector_session_id,
raw_json,
)
.await
.map(CompletedWorkerRuntimeProtocolDispatch::adapter_reply),
(None, RendererInspectorResponseDelivery::SessionSink) => {
Err("SessionResponseSenderMissing".to_owned())
}
}
});
Ok(PendingServiceWorkerRuntimeProtocolMessageDispatch {
session_id: session_id.map(str::to_owned),
pending,
response_route,
})
}
pub(crate) fn complete_service_worker_runtime_protocol_message_for_session(
&mut self,
mut completed: CompletedServiceWorkerRuntimeProtocolMessageDispatch,
) -> Result<Vec<RendererRuntimeInspectorMessage>, String> {
self.restore_frontend_command_ids_in_runtime_messages(
completed.session_id.as_deref(),
None,
&mut completed.dispatch.messages,
);
Ok(completed.dispatch.messages)
}
pub(crate) fn start_moli_diagnostics(
&mut self,
) -> Result<PendingMoliDiagnosticsDispatch, String> {
let mut pending = Vec::new();
if let Some(browser_context) = self.browser_context.as_mut() {
collect_moli_diagnostics_pending_snapshots(browser_context, &mut pending)?;
}
for browser_context in &mut self.inactive_browser_contexts {
collect_moli_diagnostics_pending_snapshots(browser_context, &mut pending)?;
}
Ok(PendingMoliDiagnosticsDispatch { pending })
}
pub(crate) fn complete_moli_diagnostics(
&mut self,
completed: CompletedMoliDiagnosticsDispatch,
) -> Value {
let mut dedicated_worker_loading_count = 0;
let mut dedicated_worker_running_worker_isolate_count = 0;
let mut document_context_count = 0;
let mut isolated_world_context_count = 0;
let mut child_default_context_count = 0;
let mut failed_page_snapshot_count = 0;
for completed in completed.completed {
let Some(page) = self
.browser_context_by_id_mut(&completed.browser_context_id)
.and_then(|browser_context| {
if let Some(target_id) = completed.target_id.as_deref() {
browser_context
.background_target_mut(target_id)
.and_then(|target| target.loaded_page_mut())
} else {
browser_context
.active_page_target_mut()
.runtime_slot
.loaded_page_mut()
}
})
else {
failed_page_snapshot_count += 1;
continue;
};
let Ok(completion) = completed.completion else {
failed_page_snapshot_count += 1;
continue;
};
let Ok(snapshot) = page.finish_page_diagnostics_snapshot(completion) else {
failed_page_snapshot_count += 1;
continue;
};
document_context_count += snapshot.diagnostics.document_context_count;
isolated_world_context_count += snapshot.diagnostics.isolated_world_context_count;
child_default_context_count += snapshot.diagnostics.child_default_context_count;
dedicated_worker_loading_count += snapshot.diagnostics.dedicated_worker_loading_count;
dedicated_worker_running_worker_isolate_count += snapshot
.diagnostics
.dedicated_worker_running_worker_isolate_count;
}
let estimated_document_isolate_count =
self.estimated_document_isolate_count_for_diagnostics();
let shared_worker_running_worker_isolate_count = self
.browser_contexts()
.map(|browser_context| {
browser_context
.shared_worker_runtime_diagnostics_for_diagnostics()
.running_worker_isolate_count
})
.sum::<usize>();
let estimated_worker_isolate_count = dedicated_worker_running_worker_isolate_count
+ shared_worker_running_worker_isolate_count;
let estimated_live_v8_isolate_count =
estimated_document_isolate_count + estimated_worker_isolate_count;
let mut diagnostics = self.moli_memory_diagnostics();
diagnostics["isolateScope"]["documentContextCount"] = json!(document_context_count);
diagnostics["isolateScope"]["isolatedWorldContextCount"] =
json!(isolated_world_context_count);
diagnostics["isolateScope"]["childDefaultContextCount"] =
json!(child_default_context_count);
diagnostics["isolateScope"]["dedicatedWorkerLoadingCount"] =
json!(dedicated_worker_loading_count);
diagnostics["isolateScope"]["dedicatedWorkerRunningWorkerIsolateCount"] =
json!(dedicated_worker_running_worker_isolate_count);
diagnostics["isolateScope"]["dedicatedWorkerDiagnosticsFailedPageSnapshotCount"] =
json!(failed_page_snapshot_count);
diagnostics["isolateScope"]["estimatedWorkerIsolateCount"] =
json!(estimated_worker_isolate_count);
diagnostics["isolateScope"]["estimatedLiveV8IsolateCount"] =
json!(estimated_live_v8_isolate_count);
diagnostics
}
}