Skip to content

armgit / moli

Public Imported from GitHub
0

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

124 KB
Raw Blame
use std::collections::{HashMap, HashSet};

use moli_bounded_buffer::{BoundedByteBuffer, ByteLimits, InsertOutcome};
use moli_core::page::{ScriptNetworkOutputItem, SubresourceNetworkRequestHandle};

use crate::automation::DevToolsNetworkDataType;
use crate::conn::{CapturedBody, ConnectionNetworkRequestIdAllocator};

use super::{
    PendingNetworkBacklogDeliverySnapshot, PendingSubresourceNetworkActivity,
    PendingSubresourceNetworkActivitySession, PendingWebSocketNetworkActivity,
    PendingWebSocketNetworkActivitySession, TargetNetworkBacklogPreparedDelivery,
    TargetNetworkBacklogRequestIdResolver, TargetNetworkOutputQueue, TargetSubresourcePlanOutput,
};

const RESPONSE_BODY_BUFFER_MAX_TOTAL_BYTES: usize = 20_000_000;
const RESPONSE_BODY_BUFFER_MAX_ENTRY_BYTES: usize = 2_000_000;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum RendererSubresourceTeardownDisposition {
    RequiresDocumentTerminal,
    DetachedKeepalive,
}

#[derive(Debug, Clone, Default, PartialEq)]
pub struct TargetNetworkAgentState {
    primary_enabled: bool,
    attached_event_session_ids: Vec<String>,
    output_queue: TargetNetworkOutputQueue,
    active_renderer_subresource_requests:
        HashMap<SubresourceNetworkRequestHandle, RendererSubresourceTeardownDisposition>,
    artifacts: TargetNetworkArtifacts,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CollectedNetworkDataArtifact {
    pub(crate) request_id: String,
    pub(crate) data_type: DevToolsNetworkDataType,
    pub(crate) body: CapturedBody,
    pub(crate) collector_ids: Vec<String>,
    pub(crate) collection_was_gated: bool,
}

struct NetworkBacklogRequestIdPlan<'a> {
    subresource_artifacts: &'a mut SubresourceNetworkArtifacts,
    websocket_artifacts: &'a mut WebSocketNetworkArtifacts,
    preferred_request_id: NetworkBacklogPreferredRequestIdBudget,
    request_id_allocator: &'a mut ConnectionNetworkRequestIdAllocator,
}

impl<'a> NetworkBacklogRequestIdPlan<'a> {
    fn new(
        subresource_artifacts: &'a mut SubresourceNetworkArtifacts,
        websocket_artifacts: &'a mut WebSocketNetworkArtifacts,
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        request_id_allocator: &'a mut ConnectionNetworkRequestIdAllocator,
    ) -> Self {
        let preferred_request_id = NetworkBacklogPreferredRequestIdBudget::new(
            preferred_request_id,
            subresource_artifacts,
        );
        Self {
            subresource_artifacts,
            websocket_artifacts,
            preferred_request_id,
            request_id_allocator,
        }
    }

    fn request_id_for_subresource_output(
        &mut self,
        output: &TargetSubresourcePlanOutput,
    ) -> String {
        if let Some(socket_id) = output.websocket_socket_id()
            && let Some(request_id) = self.websocket_artifacts.request_id_for_socket(socket_id)
        {
            return request_id.to_owned();
        }
        if let Some(handle) = output.request_handle()
            && let Some(request_id) = self.subresource_artifacts.request_id_for_handle(handle)
        {
            return request_id.to_owned();
        }
        let request_id = self
            .preferred_request_id
            .take_for_new_subresource(output.request_handle())
            .unwrap_or_else(|| self.request_id_allocator.allocate_request_id());
        if let Some(handle) = output.request_handle() {
            self.subresource_artifacts
                .set_request_id_for_handle_if_absent(handle, request_id.clone());
        }
        if let Some(socket_id) = output.websocket_socket_id() {
            self.websocket_artifacts
                .set_request_id_for_socket_if_absent(socket_id, request_id.clone());
        }
        request_id
    }

    fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
        if let Some(request_id) = self.websocket_artifacts.request_id_for_socket(socket_id) {
            return request_id.to_owned();
        }
        let request_id = self.request_id_allocator.allocate_request_id();
        self.websocket_artifacts
            .set_request_id_for_socket_if_absent(socket_id, request_id.clone());
        request_id
    }
}

impl TargetNetworkBacklogRequestIdResolver for NetworkBacklogRequestIdPlan<'_> {
    fn request_id_for_subresource_output(
        &mut self,
        output: &TargetSubresourcePlanOutput,
    ) -> String {
        NetworkBacklogRequestIdPlan::request_id_for_subresource_output(self, output)
    }

    fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
        NetworkBacklogRequestIdPlan::request_id_for_websocket_socket(self, socket_id)
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum NetworkBacklogPreferredRequestId<'a> {
    ContextualSubresource(&'a str),
}

impl<'a> NetworkBacklogPreferredRequestId<'a> {
    pub(crate) fn contextual_subresource(request_id: &'a str) -> Self {
        Self::ContextualSubresource(request_id)
    }

    fn value(self) -> &'a str {
        match self {
            Self::ContextualSubresource(request_id) => request_id,
        }
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct NetworkBacklogPreferredRequestIdBudget {
    value: Option<String>,
    bound_request_handle: Option<SubresourceNetworkRequestHandle>,
}

impl NetworkBacklogPreferredRequestIdBudget {
    fn new(
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        subresource_artifacts: &SubresourceNetworkArtifacts,
    ) -> Self {
        let value = preferred_request_id.map(|request_id| request_id.value().to_owned());
        // A contextual id belongs to the request whose Fetch pause produced
        // it. Once that request has a stable handle, reserve the id for that
        // handle instead of letting an older uncorrelated backlog item consume
        // it merely because that item is delivered first.
        let bound_request_handle = value
            .as_deref()
            .and_then(|request_id| subresource_artifacts.request_handle_for_request_id(request_id));
        Self {
            value,
            bound_request_handle,
        }
    }

    fn take_for_new_subresource(
        &mut self,
        request_handle: Option<SubresourceNetworkRequestHandle>,
    ) -> Option<String> {
        if self
            .bound_request_handle
            .is_some_and(|expected_handle| Some(expected_handle) != request_handle)
        {
            return None;
        }
        self.value.take()
    }
}

impl TargetNetworkAgentState {
    /// Moves the Document-owned live queue and request correlations into a
    /// short-lived predecessor state while retaining target/session policy and
    /// target-scoped body/stream artifacts for the replacement Document.
    ///
    /// A renderer Page can publish its final cancellation batch after protocol
    /// has installed its successor Page. Keeping the predecessor queue intact
    /// lets those terminal facts reuse the request ids announced before the
    /// commit without making the successor replay historical requests.
    pub(crate) fn rotate_document_for_replacement(&mut self) -> RetiringTargetNetworkAgentState {
        RetiringTargetNetworkAgentState {
            output_queue: std::mem::take(&mut self.output_queue),
            active_renderer_subresource_requests: std::mem::take(
                &mut self.active_renderer_subresource_requests,
            ),
            subresource_network_artifacts: std::mem::take(
                &mut self.artifacts.subresource_network_artifacts,
            ),
            websocket_network_artifacts: std::mem::take(
                &mut self.artifacts.websocket_network_artifacts,
            ),
        }
    }

    pub(crate) fn primary_events_enabled(&self) -> bool {
        self.primary_enabled
    }

    pub(crate) fn set_primary_events_enabled(&mut self, enabled: bool) {
        self.primary_enabled = enabled;
    }

    #[cfg(test)]
    pub(crate) fn enable_primary_events(&mut self) {
        self.set_primary_events_enabled(true);
    }

    pub(crate) fn disable_primary_events(&mut self) {
        self.set_primary_events_enabled(false);
    }

    pub(crate) fn reset_output_queue(&mut self) {
        self.output_queue.reset();
        self.artifacts
            .subresource_network_artifacts
            .clear_request_ids();
        self.artifacts
            .websocket_network_artifacts
            .clear_request_ids();
    }

    /// Applies one source-bound live renderer fact and updates the protocol's
    /// authoritative in-flight request set at the same boundary.
    ///
    /// Network-idle must be derived from concrete request lifecycle facts, not
    /// from a later renderer snapshot. The exact Document check is performed
    /// by the owning runtime slot before this method is called.
    pub(crate) fn ingest_renderer_output_item(
        &mut self,
        item: &ScriptNetworkOutputItem,
        document_loader_id: &str,
    ) {
        update_active_renderer_subresource_requests(
            &mut self.active_renderer_subresource_requests,
            item,
        );
        self.output_queue
            .append_renderer_output_item_for_loader(item, document_loader_id);
    }

    /// Applies one renderer fact and freezes exactly the delivery range that
    /// fact appended for the listeners enabled at this ingress boundary.
    ///
    /// This deliberately does not start from the sessions' emitted cursors.
    /// Several concrete renderer publications can reach ordered ingress before
    /// the first one is projected, so those cursors may still point before an
    /// earlier prepared token. Starting from them would duplicate that earlier
    /// fact in every later token. The concrete stream FIFO instead guarantees
    /// these disjoint ranges are projected in the same order they are prepared.
    pub(crate) fn ingest_renderer_output_item_and_prepare_live_delivery(
        &mut self,
        item: &ScriptNetworkOutputItem,
        document_loader_id: &str,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> TargetNetworkBacklogPreparedDelivery {
        let subresource_start = self.output_queue_subresource_record_count();
        let websocket_event_start = self.output_queue_websocket_event_count();
        self.ingest_renderer_output_item(item, document_loader_id);

        let sessions = self.event_session_ids(trigger_session_id, primary_session_id);
        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(
            sessions
                .iter()
                .cloned()
                .map(|session_id| {
                    PendingSubresourceNetworkActivitySession::new(session_id, subresource_start)
                })
                .collect(),
        );
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(
            sessions
                .into_iter()
                .map(|session_id| {
                    PendingWebSocketNetworkActivitySession::new(
                        session_id,
                        subresource_start,
                        websocket_event_start,
                    )
                })
                .collect(),
        );
        let mut request_ids = NetworkBacklogRequestIdPlan::new(
            &mut self.artifacts.subresource_network_artifacts,
            &mut self.artifacts.websocket_network_artifacts,
            preferred_request_id,
            request_id_allocator,
        );
        let delivery = self.output_queue.backlog_prepared_delivery_for_activity(
            subresource_activity,
            websocket_activity,
            &mut request_ids,
        );
        if !self.has_event_listeners() {
            self.discard_observed_delivery_outputs();
        }
        delivery
    }

    pub(crate) fn renderer_subresources_are_idle(&self) -> bool {
        self.active_renderer_subresource_requests.is_empty()
    }

    fn output_queue_subresource_record_count(&self) -> usize {
        self.output_queue.subresource_record_count()
    }

    fn output_queue_websocket_event_count(&self) -> usize {
        self.output_queue.websocket_event_count()
    }

    pub(crate) fn enable_attached_events(&mut self, session_id: &str) {
        if !self
            .attached_event_session_ids
            .iter()
            .any(|enabled_session_id| enabled_session_id == session_id)
        {
            self.attached_event_session_ids.push(session_id.to_owned());
        }
    }

    pub(crate) fn disable_attached_events(&mut self, session_id: &str) -> bool {
        let previous_len = self.attached_event_session_ids.len();
        self.attached_event_session_ids
            .retain(|enabled_session_id| enabled_session_id != session_id);
        self.attached_event_session_ids.len() != previous_len
    }

    pub(crate) fn remove_attached_session(&mut self, session_id: &str) {
        self.disable_attached_events(session_id);
        self.remove_session_observation_cursor(Some(session_id));
    }

    pub(crate) fn has_event_listeners(&self) -> bool {
        self.primary_enabled || !self.attached_event_session_ids.is_empty()
    }

    pub(crate) fn attached_events_enabled_for_session(&self, session_id: &str) -> bool {
        self.attached_event_session_ids
            .iter()
            .any(|enabled_session_id| enabled_session_id == session_id)
    }

    pub(crate) fn event_session_ids(
        &self,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
    ) -> Vec<Option<String>> {
        let mut session_ids = Vec::new();
        let primary_event_session_id = primary_session_id.or(trigger_session_id);
        if self.primary_enabled {
            session_ids.push(primary_event_session_id.map(str::to_owned));
        }
        for session_id in &self.attached_event_session_ids {
            if !self.primary_enabled || Some(session_id.as_str()) != primary_event_session_id {
                session_ids.push(Some(session_id.clone()));
            }
        }
        session_ids
    }

    pub(crate) fn pending_subresource_activity(
        &self,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
    ) -> Option<PendingSubresourceNetworkActivity> {
        let sessions = self
            .event_session_ids(trigger_session_id, primary_session_id)
            .into_iter()
            .map(|session_id| {
                let start_index = self
                    .artifacts
                    .subresource_network_artifacts
                    .emitted_record_count_for_session(session_id.as_deref());
                PendingSubresourceNetworkActivitySession::new(session_id, start_index)
            })
            .collect::<Vec<_>>();
        PendingSubresourceNetworkActivity::from_sessions(sessions)
    }

    pub(crate) fn pending_websocket_activity(
        &self,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
    ) -> Option<PendingWebSocketNetworkActivity> {
        let sessions = self
            .event_session_ids(trigger_session_id, primary_session_id)
            .into_iter()
            .map(|session_id| {
                let record_start_index = self
                    .artifacts
                    .websocket_network_artifacts
                    .emitted_record_count_for_session(session_id.as_deref());
                let event_start_index = self
                    .artifacts
                    .websocket_network_artifacts
                    .emitted_event_count_for_session(session_id.as_deref());
                PendingWebSocketNetworkActivitySession::new(
                    session_id,
                    record_start_index,
                    event_start_index,
                )
            })
            .collect::<Vec<_>>();
        PendingWebSocketNetworkActivity::from_sessions(sessions)
    }

    pub(crate) fn pending_network_backlog_delivery_snapshot(
        &mut self,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> Option<PendingNetworkBacklogDeliverySnapshot> {
        let mut backlog = self.backlog_prepared_delivery(
            trigger_session_id,
            primary_session_id,
            preferred_request_id,
            request_id_allocator,
        );
        self.pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
    }

    pub(crate) fn pending_network_backlog_delivery_snapshot_from_backlog(
        &mut self,
        backlog: &mut TargetNetworkBacklogPreparedDelivery,
    ) -> Option<PendingNetworkBacklogDeliverySnapshot> {
        self.output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(backlog)
    }

    pub(crate) fn backlog_prepared_delivery(
        &mut self,
        trigger_session_id: Option<&str>,
        primary_session_id: Option<&str>,
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> TargetNetworkBacklogPreparedDelivery {
        let subresource_activity =
            self.pending_subresource_activity(trigger_session_id, primary_session_id);
        let websocket_activity =
            self.pending_websocket_activity(trigger_session_id, primary_session_id);
        let mut request_ids = NetworkBacklogRequestIdPlan::new(
            &mut self.artifacts.subresource_network_artifacts,
            &mut self.artifacts.websocket_network_artifacts,
            preferred_request_id,
            request_id_allocator,
        );
        self.output_queue.backlog_prepared_delivery_for_activity(
            subresource_activity,
            websocket_activity,
            &mut request_ids,
        )
    }

    pub(crate) fn initialize_session_observation_cursor_at_output_tail(
        &mut self,
        session_id: Option<&str>,
    ) {
        let subresource_record_count = self.output_queue_subresource_record_count();
        let websocket_event_count = self.output_queue_websocket_event_count();
        self.artifacts
            .subresource_network_artifacts
            .set_session_cursor(session_id, subresource_record_count);
        self.artifacts
            .websocket_network_artifacts
            .set_session_cursors(session_id, subresource_record_count, websocket_event_count);
        self.discard_observed_delivery_outputs();
    }

    pub(crate) fn remove_session_observation_cursor(&mut self, session_id: Option<&str>) {
        self.artifacts
            .subresource_network_artifacts
            .remove_session_cursor(session_id);
        self.artifacts
            .websocket_network_artifacts
            .remove_session_cursors(session_id);
        self.discard_observed_delivery_outputs();
    }

    pub(crate) fn collected_network_data_artifacts(&self) -> Vec<CollectedNetworkDataArtifact> {
        self.artifacts.collected_network_data_artifacts()
    }

    pub(crate) fn record_subresource_request_id_for_handle_if_absent(
        &mut self,
        handle: SubresourceNetworkRequestHandle,
        request_id: String,
    ) {
        self.artifacts
            .subresource_network_artifacts
            .set_request_id_for_handle_if_absent(handle, request_id);
    }

    pub(crate) fn record_fetch_pause_announced_request_id(&mut self, request_id: String) {
        self.artifacts
            .subresource_network_artifacts
            .record_fetch_pause_announced_request_id(request_id);
    }

    pub(crate) fn take_fetch_pause_announced_request_id(&mut self, request_id: &str) -> bool {
        self.artifacts
            .subresource_network_artifacts
            .take_fetch_pause_announced_request_id(request_id)
    }

    pub(crate) fn clear_fetch_pause_announced_request_id(&mut self, request_id: &str) {
        self.artifacts
            .subresource_network_artifacts
            .clear_fetch_pause_announced_request_id(request_id);
    }

    pub(crate) fn request_id_for_subresource_handle(
        &mut self,
        handle: SubresourceNetworkRequestHandle,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> String {
        if let Some(request_id) = self
            .artifacts
            .subresource_network_artifacts
            .request_id_for_handle(handle)
        {
            return request_id.to_owned();
        }
        let request_id = request_id_allocator.allocate_request_id();
        self.artifacts
            .subresource_network_artifacts
            .set_request_id_for_handle_if_absent(handle, request_id.clone());
        request_id
    }

    pub(crate) fn claim_completed_subresource_request_id(&mut self, request_id: &str) -> bool {
        self.artifacts
            .subresource_network_artifacts
            .claim_completed_request_id(request_id)
    }

    #[cfg(test)]
    pub(crate) fn allocate_network_request_id(&mut self) -> String {
        self.artifacts.allocate_network_request_id()
    }

    #[cfg(test)]
    pub(crate) fn set_session_observation_cursor_at_counts_for_test(
        &mut self,
        session_id: Option<&str>,
        subresource_count: usize,
        websocket_count: usize,
    ) {
        self.artifacts.set_session_observation_cursor_at_counts(
            session_id,
            subresource_count,
            websocket_count,
        );
    }

    #[cfg(test)]
    pub(crate) fn emitted_subresource_record_count_for_session_for_test(
        &self,
        session_id: Option<&str>,
    ) -> usize {
        self.artifacts
            .emitted_subresource_record_count_for_session(session_id)
    }

    #[cfg(test)]
    pub(crate) fn emitted_websocket_event_count_for_session_for_test(
        &self,
        session_id: Option<&str>,
    ) -> usize {
        self.artifacts
            .emitted_websocket_event_count_for_session(session_id)
    }

    #[cfg(test)]
    pub(crate) fn artifacts_are_default_for_test(&self) -> bool {
        self.artifacts == TargetNetworkArtifacts::default()
    }

    #[cfg(test)]
    pub(crate) fn record_captured_response_body(
        &mut self,
        request_id: String,
        response_body: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
    ) {
        self.artifacts
            .body_artifacts
            .insert(request_id, response_body, session_ids);
    }

    pub(crate) fn record_captured_response_body_source_with_collector_scope(
        &mut self,
        request_id: String,
        response_body: CapturedBody,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.artifacts
            .body_artifacts
            .insert_captured_body_with_collector_scope(
                request_id,
                response_body,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn record_captured_request_body_with_collector_scope(
        &mut self,
        request_id: String,
        request_body: bytes::Bytes,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.artifacts
            .body_artifacts
            .insert_request_body_with_collector_scope(
                request_id,
                request_body,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    #[cfg(test)]
    pub(crate) fn record_pending_response_body(
        &mut self,
        request_id: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
    ) {
        self.record_pending_response_body_with_collector_scope(
            request_id,
            session_ids,
            std::iter::empty::<String>(),
            false,
        );
    }

    pub(crate) fn record_pending_response_body_with_collector_scope(
        &mut self,
        request_id: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.artifacts
            .body_artifacts
            .insert_pending_with_collector_scope(
                request_id,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn record_failed_response_body_with_collector_scope(
        &mut self,
        request_id: String,
        error_text: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.artifacts
            .body_artifacts
            .insert_failed_with_collector_scope(
                request_id,
                error_text,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn captured_response_body(&self, request_id: &str) -> Option<&CapturedResponseBody> {
        self.artifacts
            .body_artifacts
            .captured_response_body(request_id)
    }

    pub(crate) fn captured_request_body(&self, request_id: &str) -> Option<&CapturedRequestBody> {
        self.artifacts
            .body_artifacts
            .captured_request_body(request_id)
    }

    pub(crate) fn clear_captured_response_bodies(&mut self) {
        self.artifacts
            .body_artifacts
            .clear_captured_response_bodies();
    }

    pub(crate) fn clear_body_artifacts(&mut self) {
        self.artifacts.body_artifacts.clear_session_scoped();
    }

    pub(crate) fn remove_captured_response_body_visibility_for_session(
        &mut self,
        session_id: Option<&str>,
    ) {
        self.artifacts
            .body_artifacts
            .remove_session_visibility(session_id);
    }

    pub(crate) fn allocate_io_stream_handle(&mut self) -> String {
        self.artifacts.body_artifacts.allocate_io_stream_handle()
    }

    pub(crate) fn insert_io_stream(&mut self, handle: String, bytes: Vec<u8>, offset: usize) {
        self.artifacts
            .body_artifacts
            .insert_stream(handle, bytes, offset);
    }

    pub(crate) fn insert_io_stream_body_source(
        &mut self,
        handle: String,
        body: CapturedBody,
        offset: usize,
    ) {
        self.artifacts
            .body_artifacts
            .insert_stream_body_source(handle, body, offset);
    }

    pub(crate) fn read_io_stream(
        &mut self,
        handle: &str,
        offset: Option<usize>,
        size: Option<usize>,
    ) -> Option<TargetIoStreamRead> {
        self.artifacts
            .body_artifacts
            .read_io_stream(handle, offset, size)
    }

    pub(crate) fn close_io_stream(&mut self, handle: &str) -> bool {
        self.artifacts.body_artifacts.close_io_stream(handle)
    }

    pub(crate) fn mark_subresource_records_emitted(
        &mut self,
        session_id: Option<&str>,
        start_index: usize,
        record_count: usize,
    ) {
        self.artifacts.subresource_network_artifacts.mark_emitted(
            session_id,
            start_index,
            record_count,
        );
    }

    pub(crate) fn reset_subresource_cursor(&mut self) {
        self.artifacts.subresource_network_artifacts.reset_cursor();
    }

    pub(crate) fn mark_websocket_activity_emitted(
        &mut self,
        session_id: Option<&str>,
        record_start_index: usize,
        record_count: usize,
        event_start_index: usize,
        event_count: usize,
    ) {
        self.artifacts.websocket_network_artifacts.mark_emitted(
            session_id,
            record_start_index,
            record_count,
            event_start_index,
            event_count,
        );
    }

    pub(crate) fn mark_network_backlog_delivery_snapshot_emitted(
        &mut self,
        snapshot: &PendingNetworkBacklogDeliverySnapshot,
    ) {
        for cursor in snapshot.subresource_cursor_advances() {
            self.mark_subresource_records_emitted(
                cursor.session_id(),
                cursor.start_index(),
                cursor.record_count(),
            );
        }
        for cursor in snapshot.websocket_cursor_advances() {
            self.mark_websocket_activity_emitted(
                cursor.session_id(),
                cursor.record_start_index(),
                cursor.record_count(),
                cursor.event_start_index(),
                cursor.event_count(),
            );
        }
        self.discard_observed_delivery_outputs();
    }

    fn discard_observed_delivery_outputs(&mut self) {
        let (subresource_record_cursor, websocket_record_cursor, websocket_event_cursor) =
            if self.has_event_listeners() {
                (
                    self.artifacts
                        .subresource_network_artifacts
                        .minimum_emitted_record_count()
                        .unwrap_or(0),
                    self.artifacts
                        .websocket_network_artifacts
                        .minimum_emitted_record_count()
                        .unwrap_or(0),
                    self.artifacts
                        .websocket_network_artifacts
                        .minimum_emitted_event_count()
                        .unwrap_or(0),
                )
            } else {
                (
                    self.output_queue_subresource_record_count(),
                    self.output_queue_subresource_record_count(),
                    self.output_queue_websocket_event_count(),
                )
            };
        self.output_queue.discard_observed_delivery_outputs(
            subresource_record_cursor,
            websocket_record_cursor,
            websocket_event_cursor,
        );
    }

    pub(crate) fn clear_websocket_request_ids(&mut self) {
        self.artifacts
            .websocket_network_artifacts
            .clear_request_ids();
    }

    pub(crate) fn clear_websocket_artifacts(&mut self) {
        self.artifacts.websocket_network_artifacts.clear_all();
    }

    pub(crate) fn register_synthetic_websocket_request(
        &mut self,
        request_id: String,
        network_request_id: String,
        socket_id: u64,
    ) {
        self.artifacts
            .websocket_network_artifacts
            .register_synthetic_request(request_id, network_request_id, socket_id);
    }

    pub(crate) fn synthetic_websocket_socket_id_for_request(
        &self,
        request_id: &str,
    ) -> Option<u64> {
        self.artifacts
            .websocket_network_artifacts
            .synthetic_socket_id_for_request(request_id)
    }

    #[cfg(test)]
    fn record_websocket_request_id_for_socket_if_absent(
        &mut self,
        socket_id: u64,
        request_id: String,
    ) {
        self.artifacts
            .record_websocket_request_id_for_socket_if_absent(socket_id, request_id);
    }

    #[cfg(test)]
    fn websocket_request_id_for_socket_or_allocate(&mut self, socket_id: u64) -> String {
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        self.websocket_request_id_for_socket_or_allocate_with(socket_id, &mut request_id_allocator)
    }

    #[cfg(test)]
    fn websocket_request_id_for_socket_or_allocate_with(
        &mut self,
        socket_id: u64,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> String {
        self.artifacts
            .request_id_for_websocket_socket(socket_id, request_id_allocator)
    }

    pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {
        self.artifacts.reset_all_target_scoped_artifacts();
    }

    #[cfg(test)]
    pub(crate) fn has_attached_events_for_session(&self, session_id: &str) -> bool {
        self.attached_events_enabled_for_session(session_id)
    }

    #[cfg(test)]
    pub(crate) fn has_captured_response_body(&self, request_id: &str) -> bool {
        self.artifacts.body_artifacts.contains_body_key(request_id)
    }

    #[cfg(test)]
    pub(crate) fn captured_response_bodies_empty(&self) -> bool {
        self.artifacts
            .body_artifacts
            .captured_response_bodies_empty()
    }

    #[cfg(test)]
    pub(crate) fn set_next_network_request_sequence_for_test(&mut self, sequence: u64) {
        self.artifacts
            .request_id_allocator
            .set_next_sequence_for_test(sequence);
    }

    #[cfg(test)]
    pub(crate) fn next_network_request_sequence_for_test(&self) -> u64 {
        self.artifacts.request_id_allocator.next_sequence_for_test()
    }

    #[cfg(test)]
    pub(crate) fn io_streams_empty(&self) -> bool {
        self.artifacts.body_artifacts.io_streams_empty()
    }

    #[cfg(test)]
    pub(crate) fn set_next_io_stream_sequence_for_test(&mut self, sequence: u64) {
        self.artifacts
            .body_artifacts
            .set_next_stream_id_for_test(sequence);
    }

    #[cfg(test)]
    pub(crate) fn next_io_stream_sequence_for_test(&self) -> u64 {
        self.artifacts.body_artifacts.next_stream_id_for_test()
    }

    #[cfg(test)]
    pub(crate) fn set_subresource_emitted_record_count_for_test(&mut self, count: usize) {
        self.artifacts
            .subresource_network_artifacts
            .set_emitted_record_count_for_test(count);
    }

    #[cfg(test)]
    pub(crate) fn subresource_emitted_record_count_for_test(&self) -> usize {
        self.artifacts
            .subresource_network_artifacts
            .emitted_record_count()
    }
}

/// Network lifecycle state retained until a replaced Document has published
/// its final output, including any detached keepalive request terminals.
#[derive(Debug)]
pub(crate) struct RetiringTargetNetworkAgentState {
    output_queue: TargetNetworkOutputQueue,
    active_renderer_subresource_requests:
        HashMap<SubresourceNetworkRequestHandle, RendererSubresourceTeardownDisposition>,
    subresource_network_artifacts: SubresourceNetworkArtifacts,
    websocket_network_artifacts: WebSocketNetworkArtifacts,
}

impl RetiringTargetNetworkAgentState {
    pub(crate) fn has_pending_renderer_requests(&self) -> bool {
        !self.active_renderer_subresource_requests.is_empty()
    }

    pub(crate) fn ingest_renderer_output_item_and_prepare_live_delivery(
        &mut self,
        item: &ScriptNetworkOutputItem,
        document_loader_id: &str,
        event_session_ids: Vec<Option<String>>,
        preferred_request_id: Option<NetworkBacklogPreferredRequestId<'_>>,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> TargetNetworkBacklogPreparedDelivery {
        update_active_renderer_subresource_requests(
            &mut self.active_renderer_subresource_requests,
            item,
        );

        let subresource_start = self.output_queue.subresource_record_count();
        let websocket_event_start = self.output_queue.websocket_event_count();
        self.output_queue
            .append_renderer_output_item_for_loader(item, document_loader_id);
        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(
            event_session_ids
                .iter()
                .cloned()
                .map(|session_id| {
                    PendingSubresourceNetworkActivitySession::new(session_id, subresource_start)
                })
                .collect(),
        );
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(
            event_session_ids
                .into_iter()
                .map(|session_id| {
                    PendingWebSocketNetworkActivitySession::new(
                        session_id,
                        subresource_start,
                        websocket_event_start,
                    )
                })
                .collect(),
        );
        let mut request_ids = NetworkBacklogRequestIdPlan::new(
            &mut self.subresource_network_artifacts,
            &mut self.websocket_network_artifacts,
            preferred_request_id,
            request_id_allocator,
        );
        self.output_queue.backlog_prepared_delivery_for_activity(
            subresource_activity,
            websocket_activity,
            &mut request_ids,
        )
    }

    pub(crate) fn unterminated_document_bound_request_diagnostics(
        &self,
    ) -> Vec<(u64, Option<&str>)> {
        let mut handles = self
            .active_renderer_subresource_requests
            .iter()
            .filter_map(|(&handle, &disposition)| {
                (disposition == RendererSubresourceTeardownDisposition::RequiresDocumentTerminal)
                    .then_some(handle)
            })
            .collect::<Vec<_>>();
        handles.sort_unstable_by_key(|handle| handle.get());
        handles
            .into_iter()
            .map(|handle| {
                (
                    handle.get(),
                    self.subresource_network_artifacts
                        .request_id_for_handle(handle),
                )
            })
            .collect()
    }
}

fn update_active_renderer_subresource_requests(
    active_requests: &mut HashMap<
        SubresourceNetworkRequestHandle,
        RendererSubresourceTeardownDisposition,
    >,
    item: &ScriptNetworkOutputItem,
) {
    match item {
        ScriptNetworkOutputItem::SubresourceRequestStarted(request) => {
            let disposition = if request.keepalive() {
                RendererSubresourceTeardownDisposition::DetachedKeepalive
            } else {
                RendererSubresourceTeardownDisposition::RequiresDocumentTerminal
            };
            active_requests.insert(request.handle(), disposition);
        }
        ScriptNetworkOutputItem::SubresourceBodyFinished(body) => {
            active_requests.remove(&body.handle());
        }
        ScriptNetworkOutputItem::SubresourceNetworkRecord(record) => {
            if let Some(handle) = record.request_handle() {
                active_requests.remove(&handle);
            }
        }
        ScriptNetworkOutputItem::SubresourceResponseStarted(_)
        | ScriptNetworkOutputItem::SubresourceDataReceived(_)
        | ScriptNetworkOutputItem::SubresourceEventSourceMessageReceived(_)
        | ScriptNetworkOutputItem::WebSocketNetworkEvent(_)
        | ScriptNetworkOutputItem::WebSocketLifecycleEvent(_) => {}
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CapturedResponseBody {
    state: CapturedResponseBodyState,
    session_ids: HashSet<Option<String>>,
    collector_ids: HashSet<String>,
    collection_was_gated: bool,
}

#[derive(Debug, Clone, PartialEq, Eq)]
enum CapturedResponseBodyState {
    Pending,
    Ready(CapturedBody),
    Failed(String),
    Evicted,
}

impl CapturedResponseBody {
    pub(crate) fn pending_with_collector_scope(
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) -> Self {
        let collector_ids = collector_ids.into_iter().collect::<HashSet<_>>();
        Self {
            state: CapturedResponseBodyState::Pending,
            session_ids: session_ids.into_iter().collect(),
            collection_was_gated: collection_was_gated || !collector_ids.is_empty(),
            collector_ids,
        }
    }

    pub(crate) fn from_captured_body_with_collector_scope(
        body: CapturedBody,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) -> Self {
        let collector_ids = collector_ids.into_iter().collect::<HashSet<_>>();
        Self {
            state: CapturedResponseBodyState::Ready(body),
            session_ids: session_ids.into_iter().collect(),
            collection_was_gated: collection_was_gated || !collector_ids.is_empty(),
            collector_ids,
        }
    }

    pub(crate) fn failed_with_collector_scope(
        error_text: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) -> Self {
        let collector_ids = collector_ids.into_iter().collect::<HashSet<_>>();
        Self {
            state: CapturedResponseBodyState::Failed(error_text),
            session_ids: session_ids.into_iter().collect(),
            collection_was_gated: collection_was_gated || !collector_ids.is_empty(),
            collector_ids,
        }
    }

    #[cfg(test)]
    pub(crate) fn body(&self) -> String {
        match &self.state {
            CapturedResponseBodyState::Ready(body) => {
                body.materialize_lossy_string().unwrap_or_default()
            }
            CapturedResponseBodyState::Pending
            | CapturedResponseBodyState::Failed(_)
            | CapturedResponseBodyState::Evicted => String::new(),
        }
    }

    pub(crate) fn body_bytes_limited(&self, limit: usize) -> anyhow::Result<Vec<u8>> {
        match &self.state {
            CapturedResponseBodyState::Ready(body) => body.materialize_bytes_limited(limit),
            CapturedResponseBodyState::Pending => {
                anyhow::bail!("No data found for resource with given identifier")
            }
            CapturedResponseBodyState::Failed(_) => {
                anyhow::bail!("No data found for resource with given identifier")
            }
            CapturedResponseBodyState::Evicted => {
                anyhow::bail!("Request content was evicted from inspector cache")
            }
        }
    }

    pub(crate) fn is_visible_to_session(&self, session_id: Option<&str>) -> bool {
        self.session_ids
            .contains(&session_id.map(std::borrow::ToOwned::to_owned))
    }

    pub(crate) fn was_collected_by(&self, collector_id: &str) -> bool {
        self.collector_ids.contains(collector_id)
    }

    pub(crate) fn collector_ids(&self) -> &HashSet<String> {
        &self.collector_ids
    }

    fn collected_network_data_artifact(
        &self,
        request_id: &str,
    ) -> Option<CollectedNetworkDataArtifact> {
        if self.collector_ids.is_empty() {
            return None;
        }
        let CapturedResponseBodyState::Ready(body) = &self.state else {
            return None;
        };
        Some(CollectedNetworkDataArtifact {
            request_id: request_id.to_owned(),
            data_type: DevToolsNetworkDataType::Response,
            body: body.clone(),
            collector_ids: sorted_collector_ids(&self.collector_ids),
            collection_was_gated: self.collection_was_gated,
        })
    }

    pub(crate) fn remove_session_visibility(&mut self, session_id: Option<&str>) -> bool {
        self.session_ids
            .remove(&session_id.map(std::borrow::ToOwned::to_owned));
        !self.session_ids.is_empty()
    }

    fn mark_evicted(&mut self) {
        self.state = CapturedResponseBodyState::Evicted;
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CapturedRequestBody {
    body: CapturedBody,
    session_ids: HashSet<Option<String>>,
    collector_ids: HashSet<String>,
    collection_was_gated: bool,
}

impl CapturedRequestBody {
    pub(crate) fn new_with_collector_scope(
        body: bytes::Bytes,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) -> Self {
        let collector_ids = collector_ids.into_iter().collect::<HashSet<_>>();
        Self {
            body: CapturedBody::from_bytes(body),
            session_ids: session_ids.into_iter().collect(),
            collection_was_gated: collection_was_gated || !collector_ids.is_empty(),
            collector_ids,
        }
    }

    pub(crate) fn body_bytes_limited(&self, limit: usize) -> anyhow::Result<Vec<u8>> {
        self.body.materialize_bytes_limited(limit)
    }

    pub(crate) fn is_visible_to_session(&self, session_id: Option<&str>) -> bool {
        self.session_ids
            .contains(&session_id.map(std::borrow::ToOwned::to_owned))
    }

    pub(crate) fn was_collected_by(&self, collector_id: &str) -> bool {
        self.collector_ids.contains(collector_id)
    }

    pub(crate) fn collector_ids(&self) -> &HashSet<String> {
        &self.collector_ids
    }

    fn collected_network_data_artifact(
        &self,
        request_id: &str,
    ) -> Option<CollectedNetworkDataArtifact> {
        if self.collector_ids.is_empty() {
            return None;
        }
        Some(CollectedNetworkDataArtifact {
            request_id: request_id.to_owned(),
            data_type: DevToolsNetworkDataType::Request,
            body: self.body.clone(),
            collector_ids: sorted_collector_ids(&self.collector_ids),
            collection_was_gated: self.collection_was_gated,
        })
    }

    pub(crate) fn remove_session_visibility(&mut self, session_id: Option<&str>) -> bool {
        self.session_ids
            .remove(&session_id.map(std::borrow::ToOwned::to_owned));
        !self.session_ids.is_empty()
    }
}

fn sorted_collector_ids(collector_ids: &HashSet<String>) -> Vec<String> {
    let mut collector_ids = collector_ids.iter().cloned().collect::<Vec<_>>();
    collector_ids.sort();
    collector_ids
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct CapturedRequestBodyStore {
    bodies: HashMap<String, CapturedRequestBody>,
}

impl CapturedRequestBodyStore {
    pub(crate) fn insert_with_collector_scope(
        &mut self,
        request_id: String,
        body: bytes::Bytes,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.bodies.insert(
            request_id,
            CapturedRequestBody::new_with_collector_scope(
                body,
                session_ids,
                collector_ids,
                collection_was_gated,
            ),
        );
    }

    pub(crate) fn get(&self, request_id: &str) -> Option<&CapturedRequestBody> {
        self.bodies.get(request_id)
    }

    fn collected_network_data_artifacts(&self) -> Vec<CollectedNetworkDataArtifact> {
        self.bodies
            .iter()
            .filter_map(|(request_id, body)| body.collected_network_data_artifact(request_id))
            .collect()
    }

    pub(crate) fn clear(&mut self) {
        self.bodies.clear();
    }

    pub(crate) fn remove_session_visibility(&mut self, session_id: Option<&str>) {
        self.bodies
            .retain(|_, body| body.remove_session_visibility(session_id));
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct CapturedResponseBodyStore {
    /// Terminal entries without retained payloads. Ready entries live only in
    /// `buffered_bodies`, making the bounded buffer the single body owner.
    bodies: HashMap<String, CapturedResponseBody>,
    buffered_bodies: BoundedByteBuffer<String, CapturedResponseBody>,
}

impl Default for CapturedResponseBodyStore {
    fn default() -> Self {
        Self::with_limits(ByteLimits::new(
            RESPONSE_BODY_BUFFER_MAX_TOTAL_BYTES,
            RESPONSE_BODY_BUFFER_MAX_ENTRY_BYTES,
        ))
    }
}

impl CapturedResponseBodyStore {
    fn with_limits(limits: ByteLimits) -> Self {
        Self {
            bodies: HashMap::new(),
            buffered_bodies: BoundedByteBuffer::new(limits),
        }
    }

    #[cfg(test)]
    pub(crate) fn insert(
        &mut self,
        request_id: String,
        body: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
    ) {
        self.insert_captured_body_with_collector_scope(
            request_id,
            CapturedBody::from_string(body),
            session_ids,
            std::iter::empty::<String>(),
            false,
        );
    }

    pub(crate) fn insert_captured_body_with_collector_scope(
        &mut self,
        request_id: String,
        body: CapturedBody,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        let byte_len = body.len();
        let captured = CapturedResponseBody::from_captured_body_with_collector_scope(
            body,
            session_ids,
            collector_ids,
            collection_was_gated,
        );
        self.bodies.remove(&request_id);
        match self.buffered_bodies.insert(request_id, captured, byte_len) {
            InsertOutcome::Stored { evicted } => {
                for (evicted_request_id, mut evicted_body) in evicted {
                    evicted_body.mark_evicted();
                    self.bodies.insert(evicted_request_id, evicted_body);
                }
            }
            InsertOutcome::Rejected {
                key: request_id,
                value: mut rejected_body,
            } => {
                rejected_body.mark_evicted();
                self.bodies.insert(request_id, rejected_body);
            }
        }
    }

    pub(crate) fn insert_pending_with_collector_scope(
        &mut self,
        request_id: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        if self.bodies.contains_key(&request_id)
            || self.buffered_bodies.contains_key(request_id.as_str())
        {
            return;
        }
        self.bodies.insert(
            request_id,
            CapturedResponseBody::pending_with_collector_scope(
                session_ids,
                collector_ids,
                collection_was_gated,
            ),
        );
    }

    pub(crate) fn insert_failed_with_collector_scope(
        &mut self,
        request_id: String,
        error_text: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.buffered_bodies.remove(&request_id);
        self.bodies.insert(
            request_id,
            CapturedResponseBody::failed_with_collector_scope(
                error_text,
                session_ids,
                collector_ids,
                collection_was_gated,
            ),
        );
    }

    pub(crate) fn get(&self, request_id: &str) -> Option<&CapturedResponseBody> {
        self.buffered_bodies
            .get(request_id)
            .or_else(|| self.bodies.get(request_id))
    }

    fn collected_network_data_artifacts(&self) -> Vec<CollectedNetworkDataArtifact> {
        self.buffered_bodies
            .iter()
            .chain(self.bodies.iter())
            .filter_map(|(request_id, body)| body.collected_network_data_artifact(request_id))
            .collect()
    }

    pub(crate) fn clear(&mut self) {
        self.bodies.clear();
        self.buffered_bodies.clear();
    }

    #[cfg(test)]
    pub(crate) fn is_empty(&self) -> bool {
        self.bodies.is_empty() && self.buffered_bodies.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn contains_key(&self, request_id: &str) -> bool {
        self.bodies.contains_key(request_id) || self.buffered_bodies.contains_key(request_id)
    }

    pub(crate) fn remove_session_visibility(&mut self, session_id: Option<&str>) {
        self.bodies
            .retain(|_, body| body.remove_session_visibility(session_id));

        let buffered_request_ids = self
            .buffered_bodies
            .iter()
            .map(|(request_id, _)| request_id.clone())
            .collect::<Vec<_>>();
        for request_id in buffered_request_ids {
            let retain = self
                .buffered_bodies
                .get_mut(request_id.as_str())
                .is_some_and(|body| body.remove_session_visibility(session_id));
            if !retain {
                self.buffered_bodies.remove(request_id.as_str());
            }
        }
    }

    #[cfg(test)]
    fn buffered_body_bytes(&self) -> usize {
        self.buffered_bodies.used_bytes()
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct TargetNetworkArtifacts {
    request_id_allocator: TargetNetworkRequestIdAllocator,
    body_artifacts: TargetNetworkBodyArtifacts,
    subresource_network_artifacts: SubresourceNetworkArtifacts,
    websocket_network_artifacts: WebSocketNetworkArtifacts,
}

impl TargetNetworkArtifacts {
    #[cfg(test)]
    pub(crate) fn allocate_network_request_id(&mut self) -> String {
        self.request_id_allocator.allocate_request_id()
    }

    #[cfg(test)]
    fn set_session_observation_cursor_at_counts(
        &mut self,
        session_id: Option<&str>,
        subresource_record_count: usize,
        websocket_event_count: usize,
    ) {
        self.subresource_network_artifacts
            .set_session_cursor(session_id, subresource_record_count);
        self.websocket_network_artifacts.set_session_cursors(
            session_id,
            subresource_record_count,
            websocket_event_count,
        );
    }

    fn collected_network_data_artifacts(&self) -> Vec<CollectedNetworkDataArtifact> {
        self.body_artifacts.collected_network_data_artifacts()
    }

    #[cfg(test)]
    pub(crate) fn emitted_subresource_record_count_for_session(
        &self,
        session_id: Option<&str>,
    ) -> usize {
        self.subresource_network_artifacts
            .emitted_record_count_for_session(session_id)
    }

    #[cfg(test)]
    pub(crate) fn emitted_websocket_event_count_for_session(
        &self,
        session_id: Option<&str>,
    ) -> usize {
        self.websocket_network_artifacts
            .emitted_event_count_for_session(session_id)
    }

    #[cfg(test)]
    fn request_id_for_websocket_socket(
        &mut self,
        socket_id: u64,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> String {
        if let Some(request_id) = self.websocket_request_id_for_socket(socket_id) {
            return request_id.to_owned();
        }
        let request_id = request_id_allocator.allocate_request_id();
        self.record_websocket_request_id_for_socket_if_absent(socket_id, request_id.clone());
        request_id
    }

    #[cfg(test)]
    fn websocket_request_id_for_socket(&self, socket_id: u64) -> Option<&str> {
        self.websocket_network_artifacts
            .request_id_for_socket(socket_id)
    }

    #[cfg(test)]
    fn record_websocket_request_id_for_socket_if_absent(
        &mut self,
        socket_id: u64,
        request_id: String,
    ) {
        self.websocket_network_artifacts
            .set_request_id_for_socket_if_absent(socket_id, request_id);
    }

    pub(crate) fn reset_all_target_scoped_artifacts(&mut self) {
        self.request_id_allocator.reset();
        self.body_artifacts.reset_all();
        self.subresource_network_artifacts.reset_cursor();
        self.subresource_network_artifacts.clear_request_ids();
        self.websocket_network_artifacts.clear_all();
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct TargetNetworkRequestIdAllocator {
    next_sequence: u64,
}

impl TargetNetworkRequestIdAllocator {
    #[cfg(test)]
    pub(crate) fn allocate_sequence(&mut self) -> u64 {
        self.next_sequence = self
            .next_sequence
            .checked_add(1)
            .expect("network request id sequence exhausted");
        self.next_sequence
    }

    #[cfg(test)]
    pub(crate) fn allocate_request_id(&mut self) -> String {
        format!("REQ-{}", self.allocate_sequence())
    }

    pub(crate) fn reset(&mut self) {
        self.next_sequence = 0;
    }

    #[cfg(test)]
    pub(crate) fn set_next_sequence_for_test(&mut self, sequence: u64) {
        self.next_sequence = sequence;
    }

    #[cfg(test)]
    pub(crate) fn next_sequence_for_test(&self) -> u64 {
        self.next_sequence
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct TargetNetworkBodyArtifacts {
    captured_request_bodies: CapturedRequestBodyStore,
    captured_response_bodies: CapturedResponseBodyStore,
    io_stream_artifacts: TargetIoStreamArtifacts,
}

impl TargetNetworkBodyArtifacts {
    #[cfg(test)]
    pub(crate) fn insert(
        &mut self,
        request_id: String,
        response_body: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
    ) {
        self.captured_response_bodies
            .insert(request_id, response_body, session_ids);
    }

    pub(crate) fn insert_captured_body_with_collector_scope(
        &mut self,
        request_id: String,
        response_body: CapturedBody,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.captured_response_bodies
            .insert_captured_body_with_collector_scope(
                request_id,
                response_body,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn insert_request_body_with_collector_scope(
        &mut self,
        request_id: String,
        request_body: bytes::Bytes,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.captured_request_bodies.insert_with_collector_scope(
            request_id,
            request_body,
            session_ids,
            collector_ids,
            collection_was_gated,
        );
    }

    pub(crate) fn insert_pending_with_collector_scope(
        &mut self,
        request_id: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.captured_response_bodies
            .insert_pending_with_collector_scope(
                request_id,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn insert_failed_with_collector_scope(
        &mut self,
        request_id: String,
        error_text: String,
        session_ids: impl IntoIterator<Item = Option<String>>,
        collector_ids: impl IntoIterator<Item = String>,
        collection_was_gated: bool,
    ) {
        self.captured_response_bodies
            .insert_failed_with_collector_scope(
                request_id,
                error_text,
                session_ids,
                collector_ids,
                collection_was_gated,
            );
    }

    pub(crate) fn captured_response_body(&self, request_id: &str) -> Option<&CapturedResponseBody> {
        self.captured_response_bodies.get(request_id)
    }

    pub(crate) fn captured_request_body(&self, request_id: &str) -> Option<&CapturedRequestBody> {
        self.captured_request_bodies.get(request_id)
    }

    pub(crate) fn collected_network_data_artifacts(&self) -> Vec<CollectedNetworkDataArtifact> {
        let mut artifacts = self
            .captured_request_bodies
            .collected_network_data_artifacts();
        artifacts.extend(
            self.captured_response_bodies
                .collected_network_data_artifacts(),
        );
        artifacts
    }

    pub(crate) fn clear_captured_response_bodies(&mut self) {
        self.captured_response_bodies.clear();
    }

    pub(crate) fn remove_session_visibility(&mut self, session_id: Option<&str>) {
        self.captured_request_bodies
            .remove_session_visibility(session_id);
        self.captured_response_bodies
            .remove_session_visibility(session_id);
    }

    pub(crate) fn allocate_io_stream_handle(&mut self) -> String {
        self.io_stream_artifacts.allocate_handle()
    }

    pub(crate) fn insert_stream(&mut self, handle: String, bytes: Vec<u8>, offset: usize) {
        self.io_stream_artifacts
            .insert_stream(handle, bytes, offset);
    }

    pub(crate) fn insert_stream_body_source(
        &mut self,
        handle: String,
        body: CapturedBody,
        offset: usize,
    ) {
        self.io_stream_artifacts
            .insert_stream_body_source(handle, body, offset);
    }

    pub(crate) fn read_io_stream(
        &mut self,
        handle: &str,
        offset: Option<usize>,
        size: Option<usize>,
    ) -> Option<TargetIoStreamRead> {
        self.io_stream_artifacts.read(handle, offset, size)
    }

    pub(crate) fn close_io_stream(&mut self, handle: &str) -> bool {
        self.io_stream_artifacts.remove(handle).is_some()
    }

    pub(crate) fn clear_session_scoped(&mut self) {
        self.captured_request_bodies.clear();
        self.captured_response_bodies.clear();
        self.io_stream_artifacts.clear_streams();
    }

    pub(crate) fn reset_all(&mut self) {
        self.captured_request_bodies.clear();
        self.captured_response_bodies.clear();
        self.io_stream_artifacts.reset_all();
    }

    #[cfg(test)]
    pub(crate) fn contains_body_key(&self, request_id: &str) -> bool {
        self.captured_response_bodies.contains_key(request_id)
    }

    #[cfg(test)]
    pub(crate) fn captured_response_bodies_empty(&self) -> bool {
        self.captured_response_bodies.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn io_streams_empty(&self) -> bool {
        self.io_stream_artifacts.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn set_next_stream_id_for_test(&mut self, next_stream_id: u64) {
        self.io_stream_artifacts
            .set_next_stream_id_for_test(next_stream_id);
    }

    #[cfg(test)]
    pub(crate) fn next_stream_id_for_test(&self) -> u64 {
        self.io_stream_artifacts.next_stream_id_for_test()
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct SubresourceNetworkArtifacts {
    emitted_record_counts_by_session: HashMap<Option<String>, usize>,
    request_ids_by_handle: HashMap<SubresourceNetworkRequestHandle, String>,
    completed_request_ids: HashSet<String>,
    fetch_pause_announced_request_ids: HashSet<String>,
}

impl SubresourceNetworkArtifacts {
    #[cfg(test)]
    pub(crate) fn emitted_record_count(&self) -> usize {
        self.emitted_record_counts_by_session
            .values()
            .copied()
            .max()
            .unwrap_or(0)
    }

    pub(crate) fn emitted_record_count_for_session(&self, session_id: Option<&str>) -> usize {
        self.emitted_record_counts_by_session
            .get(&session_id.map(str::to_owned))
            .copied()
            .unwrap_or(0)
    }

    fn minimum_emitted_record_count(&self) -> Option<usize> {
        self.emitted_record_counts_by_session
            .values()
            .copied()
            .min()
    }

    pub(crate) fn mark_emitted(
        &mut self,
        session_id: Option<&str>,
        start_index: usize,
        record_count: usize,
    ) {
        let cursor = start_index
            .checked_add(record_count)
            .expect("subresource emitted record cursor exhausted");
        self.set_session_cursor(session_id, cursor);
    }

    pub(crate) fn reset_cursor(&mut self) {
        self.emitted_record_counts_by_session.clear();
    }

    pub(crate) fn request_id_for_handle(
        &self,
        handle: SubresourceNetworkRequestHandle,
    ) -> Option<&str> {
        self.request_ids_by_handle.get(&handle).map(String::as_str)
    }

    fn request_handle_for_request_id(
        &self,
        request_id: &str,
    ) -> Option<SubresourceNetworkRequestHandle> {
        self.request_ids_by_handle
            .iter()
            .find_map(|(&handle, mapped_request_id)| {
                (mapped_request_id == request_id).then_some(handle)
            })
    }

    pub(crate) fn set_request_id_for_handle_if_absent(
        &mut self,
        handle: SubresourceNetworkRequestHandle,
        request_id: String,
    ) {
        self.request_ids_by_handle
            .entry(handle)
            .or_insert(request_id);
    }

    fn record_fetch_pause_announced_request_id(&mut self, request_id: String) {
        self.fetch_pause_announced_request_ids.insert(request_id);
    }

    fn take_fetch_pause_announced_request_id(&mut self, request_id: &str) -> bool {
        self.fetch_pause_announced_request_ids.remove(request_id)
    }

    fn clear_fetch_pause_announced_request_id(&mut self, request_id: &str) {
        self.fetch_pause_announced_request_ids.remove(request_id);
    }

    pub(crate) fn claim_completed_request_id(&mut self, request_id: &str) -> bool {
        self.completed_request_ids.insert(request_id.to_owned())
    }

    pub(crate) fn clear_request_ids(&mut self) {
        self.request_ids_by_handle.clear();
        self.completed_request_ids.clear();
        self.fetch_pause_announced_request_ids.clear();
    }

    pub(crate) fn set_session_cursor(&mut self, session_id: Option<&str>, record_count: usize) {
        self.emitted_record_counts_by_session
            .insert(session_id.map(str::to_owned), record_count);
    }

    pub(crate) fn remove_session_cursor(&mut self, session_id: Option<&str>) {
        self.emitted_record_counts_by_session
            .remove(&session_id.map(str::to_owned));
    }

    #[cfg(test)]
    pub(crate) fn set_emitted_record_count_for_test(&mut self, count: usize) {
        self.set_session_cursor(None, count);
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct WebSocketNetworkArtifacts {
    observation: WebSocketNetworkObservationArtifacts,
    request_ids: WebSocketRequestIdState,
}

impl WebSocketNetworkArtifacts {
    pub(crate) fn emitted_record_count_for_session(&self, session_id: Option<&str>) -> usize {
        self.observation
            .emitted_record_count_for_session(session_id)
    }

    pub(crate) fn emitted_event_count_for_session(&self, session_id: Option<&str>) -> usize {
        self.observation.emitted_event_count_for_session(session_id)
    }

    fn minimum_emitted_record_count(&self) -> Option<usize> {
        self.observation
            .emitted_record_counts_by_session
            .values()
            .copied()
            .min()
    }

    fn minimum_emitted_event_count(&self) -> Option<usize> {
        self.observation
            .emitted_event_counts_by_session
            .values()
            .copied()
            .min()
    }

    pub(crate) fn mark_emitted(
        &mut self,
        session_id: Option<&str>,
        record_start_index: usize,
        record_count: usize,
        event_start_index: usize,
        event_count: usize,
    ) {
        self.observation.mark_emitted(
            session_id,
            record_start_index,
            record_count,
            event_start_index,
            event_count,
        );
    }

    pub(crate) fn reset_cursors(&mut self) {
        self.observation.reset_cursors();
    }

    pub(crate) fn set_session_cursors(
        &mut self,
        session_id: Option<&str>,
        record_count: usize,
        event_count: usize,
    ) {
        self.observation
            .set_session_cursors(session_id, record_count, event_count);
    }

    pub(crate) fn remove_session_cursors(&mut self, session_id: Option<&str>) {
        self.observation.remove_session_cursors(session_id);
    }

    pub(crate) fn clear_request_ids(&mut self) {
        self.request_ids.clear();
    }

    pub(crate) fn clear_all(&mut self) {
        self.reset_cursors();
        self.clear_request_ids();
    }

    pub(crate) fn register_synthetic_request(
        &mut self,
        request_id: String,
        network_request_id: String,
        socket_id: u64,
    ) {
        self.request_ids
            .register_synthetic_request(request_id, network_request_id, socket_id);
    }

    pub(crate) fn synthetic_socket_id_for_request(&self, request_id: &str) -> Option<u64> {
        self.request_ids.synthetic_socket_id_for_request(request_id)
    }

    pub(crate) fn request_id_for_socket(&self, socket_id: u64) -> Option<&str> {
        self.request_ids.request_id_for_socket(socket_id)
    }

    pub(crate) fn set_request_id_for_socket_if_absent(
        &mut self,
        socket_id: u64,
        request_id: String,
    ) {
        self.request_ids
            .set_request_id_for_socket_if_absent(socket_id, request_id);
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct WebSocketNetworkObservationArtifacts {
    emitted_record_counts_by_session: HashMap<Option<String>, usize>,
    emitted_event_counts_by_session: HashMap<Option<String>, usize>,
}

impl WebSocketNetworkObservationArtifacts {
    pub(crate) fn emitted_record_count_for_session(&self, session_id: Option<&str>) -> usize {
        self.emitted_record_counts_by_session
            .get(&session_id.map(str::to_owned))
            .copied()
            .unwrap_or(0)
    }

    pub(crate) fn emitted_event_count_for_session(&self, session_id: Option<&str>) -> usize {
        self.emitted_event_counts_by_session
            .get(&session_id.map(str::to_owned))
            .copied()
            .unwrap_or(0)
    }

    pub(crate) fn mark_emitted(
        &mut self,
        session_id: Option<&str>,
        record_start_index: usize,
        record_count: usize,
        event_start_index: usize,
        event_count: usize,
    ) {
        let record_cursor = record_start_index
            .checked_add(record_count)
            .expect("websocket emitted record cursor exhausted");
        let event_cursor = event_start_index
            .checked_add(event_count)
            .expect("websocket emitted event cursor exhausted");
        self.set_session_cursors(session_id, record_cursor, event_cursor);
    }

    pub(crate) fn reset_cursors(&mut self) {
        self.emitted_record_counts_by_session.clear();
        self.emitted_event_counts_by_session.clear();
    }

    pub(crate) fn set_session_cursors(
        &mut self,
        session_id: Option<&str>,
        record_count: usize,
        event_count: usize,
    ) {
        let session_id = session_id.map(str::to_owned);
        self.emitted_record_counts_by_session
            .insert(session_id.clone(), record_count);
        self.emitted_event_counts_by_session
            .insert(session_id, event_count);
    }

    pub(crate) fn remove_session_cursors(&mut self, session_id: Option<&str>) {
        let session_id = session_id.map(str::to_owned);
        self.emitted_record_counts_by_session.remove(&session_id);
        self.emitted_event_counts_by_session.remove(&session_id);
    }
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct WebSocketRequestIdState {
    request_ids_by_socket_id: HashMap<u64, String>,
    socket_ids_by_request_id: HashMap<String, u64>,
}

impl WebSocketRequestIdState {
    pub(crate) fn clear(&mut self) {
        self.request_ids_by_socket_id.clear();
        self.socket_ids_by_request_id.clear();
    }

    pub(crate) fn register_synthetic_request(
        &mut self,
        request_id: String,
        network_request_id: String,
        socket_id: u64,
    ) {
        self.socket_ids_by_request_id.insert(request_id, socket_id);
        self.socket_ids_by_request_id
            .insert(network_request_id.clone(), socket_id);
        self.request_ids_by_socket_id
            .insert(socket_id, network_request_id);
    }

    pub(crate) fn synthetic_socket_id_for_request(&self, request_id: &str) -> Option<u64> {
        self.socket_ids_by_request_id.get(request_id).copied()
    }

    pub(crate) fn request_id_for_socket(&self, socket_id: u64) -> Option<&str> {
        self.request_ids_by_socket_id
            .get(&socket_id)
            .map(String::as_str)
    }

    pub(crate) fn set_request_id_for_socket_if_absent(
        &mut self,
        socket_id: u64,
        request_id: String,
    ) {
        self.request_ids_by_socket_id
            .entry(socket_id)
            .or_insert(request_id);
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IoStreamState {
    body: CapturedBody,
    pub offset: usize,
}

impl IoStreamState {
    pub(crate) fn from_bytes(bytes: Vec<u8>, offset: usize) -> Self {
        Self {
            body: CapturedBody::from_bytes_spooled(bytes),
            offset,
        }
    }

    pub(crate) fn from_body_source(body: CapturedBody, offset: usize) -> Self {
        Self { body, offset }
    }

    pub(crate) fn len(&self) -> usize {
        self.body.len()
    }

    pub(crate) fn read_range(&self, offset: usize, len: usize) -> Vec<u8> {
        self.body.read_range(offset, len).unwrap_or_default()
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct TargetIoStreamRead {
    pub(crate) bytes: Vec<u8>,
    pub(crate) eof: bool,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct TargetIoStreamArtifacts {
    next_stream_id: u64,
    streams: HashMap<String, IoStreamState>,
}

impl TargetIoStreamArtifacts {
    pub(crate) fn allocate_handle(&mut self) -> String {
        self.next_stream_id = self
            .next_stream_id
            .checked_add(1)
            .expect("IO stream id sequence exhausted");
        format!("STREAM-{}", self.next_stream_id)
    }

    pub(crate) fn insert_stream(&mut self, handle: String, bytes: Vec<u8>, offset: usize) {
        self.streams
            .insert(handle, IoStreamState::from_bytes(bytes, offset));
    }

    pub(crate) fn insert_stream_body_source(
        &mut self,
        handle: String,
        body: CapturedBody,
        offset: usize,
    ) {
        self.streams
            .insert(handle, IoStreamState::from_body_source(body, offset));
    }

    pub(crate) fn remove(&mut self, handle: &str) -> Option<IoStreamState> {
        self.streams.remove(handle)
    }

    pub(crate) fn read(
        &mut self,
        handle: &str,
        offset: Option<usize>,
        size: Option<usize>,
    ) -> Option<TargetIoStreamRead> {
        let stream = self.streams.get_mut(handle)?;
        let stream_len = stream.len();
        let start = offset.unwrap_or(stream.offset).min(stream_len);
        stream.offset = start;
        let requested_len = size.unwrap_or_else(|| stream_len.saturating_sub(start));
        let bytes = stream.read_range(start, requested_len);
        let end = start.saturating_add(bytes.len()).min(stream_len);
        stream.offset = end;
        Some(TargetIoStreamRead {
            bytes,
            eof: end >= stream_len,
        })
    }

    pub(crate) fn clear_streams(&mut self) {
        self.streams.clear();
    }

    pub(crate) fn reset_all(&mut self) {
        self.next_stream_id = 0;
        self.streams.clear();
    }

    #[cfg(test)]
    pub(crate) fn is_empty(&self) -> bool {
        self.streams.is_empty()
    }

    #[cfg(test)]
    pub(crate) fn set_next_stream_id_for_test(&mut self, next_stream_id: u64) {
        self.next_stream_id = next_stream_id;
    }

    #[cfg(test)]
    pub(crate) fn next_stream_id_for_test(&self) -> u64 {
        self.next_stream_id
    }
}

#[cfg(test)]
mod tests {
    use moli_core::page::{
        ScriptNetworkOutputItem, SubresourceNetworkRecord, SubresourceNetworkRequestHandle,
        SubresourceRequestInitiatorType, SubresourceRequestStarted, SubresourceResourceType,
        WebSocketFrameDirection, WebSocketFrameOpcode, WebSocketNetworkEvent,
    };
    use url::Url;

    use super::super::output_queue::{
        PendingSubresourceNetworkActivity, PendingSubresourceNetworkActivitySession,
        PendingWebSocketNetworkActivity, PendingWebSocketNetworkActivitySession,
    };
    use super::{
        CapturedResponseBodyStore, NetworkBacklogPreferredRequestId, NetworkBacklogRequestIdPlan,
        TargetNetworkAgentState, WebSocketNetworkArtifacts,
    };
    use crate::conn::{CapturedBody, CapturedBodyWriter, ConnectionNetworkRequestIdAllocator};

    #[test]
    fn response_body_store_defaults_to_one_tenth_of_chromium_desktop_budget() {
        let store = CapturedResponseBodyStore::default();

        assert_eq!(
            store.buffered_bodies.limits(),
            moli_bounded_buffer::ByteLimits::new(20_000_000, 2_000_000)
        );
    }

    #[test]
    fn response_body_store_marks_oldest_payload_evicted_when_total_budget_fills() {
        let mut store =
            CapturedResponseBodyStore::with_limits(moli_bounded_buffer::ByteLimits::new(5, 4));
        store.insert_captured_body_with_collector_scope(
            "REQ-first".to_owned(),
            CapturedBody::from_string("aa".to_owned()),
            [None],
            std::iter::empty::<String>(),
            false,
        );
        store.insert_captured_body_with_collector_scope(
            "REQ-second".to_owned(),
            CapturedBody::from_string("bb".to_owned()),
            [None],
            std::iter::empty::<String>(),
            false,
        );
        store.insert_captured_body_with_collector_scope(
            "REQ-third".to_owned(),
            CapturedBody::from_string("ccc".to_owned()),
            [None],
            std::iter::empty::<String>(),
            false,
        );

        assert_eq!(store.buffered_body_bytes(), 5);
        assert_eq!(
            store
                .get("REQ-first")
                .expect("evicted metadata must remain addressable")
                .body_bytes_limited(10)
                .expect_err("oldest payload should be evicted")
                .to_string(),
            "Request content was evicted from inspector cache"
        );
        assert_eq!(
            store
                .get("REQ-second")
                .expect("second response should remain")
                .body_bytes_limited(10)
                .expect("second response body should remain readable"),
            b"bb"
        );
        assert_eq!(
            store
                .get("REQ-third")
                .expect("third response should remain")
                .body_bytes_limited(10)
                .expect("third response body should remain readable"),
            b"ccc"
        );
    }

    #[test]
    fn response_body_store_returns_byte_charge_on_state_and_visibility_removal() {
        let mut store =
            CapturedResponseBodyStore::with_limits(moli_bounded_buffer::ByteLimits::new(8, 4));
        store.insert_captured_body_with_collector_scope(
            "REQ-failed".to_owned(),
            CapturedBody::from_string("body".to_owned()),
            [None],
            std::iter::empty::<String>(),
            false,
        );
        assert_eq!(store.buffered_body_bytes(), 4);
        store.insert_failed_with_collector_scope(
            "REQ-failed".to_owned(),
            "network failed".to_owned(),
            [None],
            std::iter::empty::<String>(),
            false,
        );
        assert_eq!(store.buffered_body_bytes(), 0);

        store.insert_captured_body_with_collector_scope(
            "REQ-session".to_owned(),
            CapturedBody::from_string("abc".to_owned()),
            [Some("SID-1".to_owned())],
            std::iter::empty::<String>(),
            false,
        );
        assert_eq!(store.buffered_body_bytes(), 3);
        store.remove_session_visibility(Some("SID-1"));
        assert_eq!(store.buffered_body_bytes(), 0);
        assert!(store.get("REQ-session").is_none());
    }

    fn subresource_record(url: &str) -> SubresourceNetworkRecord {
        let url = Url::parse(url).expect("test URL should parse");
        SubresourceNetworkRecord::success(
            None,
            Url::parse("https://example.com/").expect("document URL should parse"),
            url.clone(),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::Script,
            None,
            Vec::new(),
            url,
            200,
            Vec::new(),
            String::new(),
            Vec::new(),
        )
    }

    fn websocket_record(url: &str, socket_id: u64) -> SubresourceNetworkRecord {
        let url = Url::parse(url).expect("test URL should parse");
        SubresourceNetworkRecord::success(
            None,
            Url::parse("https://example.com/").expect("document URL should parse"),
            url.clone(),
            "GET".to_owned(),
            vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())].into(),
            None,
            SubresourceResourceType::WebSocket,
            None,
            Vec::new(),
            url,
            101,
            vec![("Upgrade".to_owned(), b"websocket".to_vec())],
            String::new(),
            Vec::new(),
        )
        .with_websocket_socket_id(socket_id)
    }

    fn websocket_event(socket_id: u64, payload_length: usize) -> WebSocketNetworkEvent {
        WebSocketNetworkEvent::new(
            socket_id,
            Url::parse("https://example.com/").expect("document URL should parse"),
            Url::parse("wss://example.com/socket").expect("websocket URL should parse"),
            WebSocketFrameDirection::Received,
            WebSocketFrameOpcode::Text,
            payload_length,
        )
    }

    fn network_output_items(
        records: &[SubresourceNetworkRecord],
        events: &[WebSocketNetworkEvent],
    ) -> Vec<ScriptNetworkOutputItem> {
        records
            .iter()
            .cloned()
            .map(|record| ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)))
            .chain(
                events
                    .iter()
                    .cloned()
                    .map(ScriptNetworkOutputItem::WebSocketNetworkEvent),
            )
            .collect()
    }

    fn ingest_network_output(
        agent: &mut TargetNetworkAgentState,
        records: &[SubresourceNetworkRecord],
        events: &[WebSocketNetworkEvent],
    ) {
        for item in network_output_items(records, events) {
            agent.ingest_renderer_output_item(&item, "LOADER-1");
        }
    }

    #[test]
    fn handled_terminal_network_record_retires_staged_request_from_idle_accounting() {
        let mut agent = TargetNetworkAgentState::default();
        let handle = SubresourceNetworkRequestHandle::new(17);
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let request_url =
            Url::parse("https://example.com/late-xhr").expect("request URL should parse");
        let started = ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(
            SubresourceRequestStarted::new(
                handle,
                None,
                document_url,
                request_url,
                "GET".to_owned(),
                Vec::new().into(),
                None,
                SubresourceResourceType::Xhr,
                SubresourceRequestInitiatorType::Script,
                None,
            ),
        ));
        agent.ingest_renderer_output_item(&started, "LOADER-1");
        assert!(!agent.renderer_subresources_are_idle());

        let terminal = ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
            subresource_record("https://example.com/late-xhr").with_request_handle(handle),
        ));
        agent.ingest_renderer_output_item(&terminal, "LOADER-1");

        assert!(
            agent.renderer_subresources_are_idle(),
            "a handled all-in-one record is terminal for the staged request with the same handle"
        );
    }

    #[test]
    fn retiring_keepalive_does_not_require_a_document_bound_terminal() {
        fn started(
            handle: SubresourceNetworkRequestHandle,
            keepalive: bool,
        ) -> ScriptNetworkOutputItem {
            ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(
                SubresourceRequestStarted::new(
                    handle,
                    None,
                    Url::parse("https://example.com/").expect("document URL should parse"),
                    Url::parse("https://example.com/collect").expect("request URL should parse"),
                    "POST".to_owned(),
                    Vec::new().into(),
                    None,
                    SubresourceResourceType::Fetch,
                    SubresourceRequestInitiatorType::Script,
                    None,
                )
                .with_keepalive(keepalive),
            ))
        }

        let mut keepalive_agent = TargetNetworkAgentState::default();
        keepalive_agent.ingest_renderer_output_item(
            &started(SubresourceNetworkRequestHandle::new(18), true),
            "LOADER-1",
        );
        assert!(
            !keepalive_agent.renderer_subresources_are_idle(),
            "a keepalive remains current-document activity until replacement"
        );
        let retiring_keepalive = keepalive_agent.rotate_document_for_replacement();
        assert!(
            retiring_keepalive
                .unterminated_document_bound_request_diagnostics()
                .is_empty(),
            "a detached keepalive may outlive its Document without a CDP terminal"
        );

        let mut ordinary_agent = TargetNetworkAgentState::default();
        ordinary_agent.ingest_renderer_output_item(
            &started(SubresourceNetworkRequestHandle::new(19), false),
            "LOADER-2",
        );
        let retiring_ordinary = ordinary_agent.rotate_document_for_replacement();
        assert_eq!(
            retiring_ordinary.unterminated_document_bound_request_diagnostics(),
            vec![(19, None)],
            "an ordinary request still requires a terminal before its renderer stream closes"
        );
    }

    fn pending_combined_snapshot(
        agent: &mut TargetNetworkAgentState,
        preferred_request_id: Option<&str>,
    ) -> super::PendingNetworkBacklogDeliverySnapshot {
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        pending_combined_snapshot_with_allocator(
            agent,
            preferred_request_id,
            &mut request_id_allocator,
        )
    }

    fn pending_combined_snapshot_with_allocator(
        agent: &mut TargetNetworkAgentState,
        preferred_request_id: Option<&str>,
        request_id_allocator: &mut ConnectionNetworkRequestIdAllocator,
    ) -> super::PendingNetworkBacklogDeliverySnapshot {
        agent
            .pending_network_backlog_delivery_snapshot(
                None,
                None,
                preferred_request_id.map(NetworkBacklogPreferredRequestId::contextual_subresource),
                request_id_allocator,
            )
            .expect("combined network backlog snapshot should be visible")
    }

    fn contextual_preferred_request_id(request_id: &str) -> NetworkBacklogPreferredRequestId<'_> {
        NetworkBacklogPreferredRequestId::contextual_subresource(request_id)
    }

    fn subresource_request_ids(
        snapshot: &super::PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<String> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_subresource()
                    .map(|output| output.request_id().to_owned())
            })
            .collect()
    }

    fn subresource_urls(snapshot: &super::PendingNetworkBacklogDeliverySnapshot) -> Vec<String> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_subresource()
                    .map(|output| output.metadata().url().as_str().to_owned())
            })
            .collect()
    }

    fn websocket_request_ids(
        snapshot: &super::PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<String> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_websocket().map(|output| {
                    output
                        .as_handshake()
                        .map(|output| output.request_id())
                        .or_else(|| output.as_frame().map(|output| output.request_id()))
                        .expect("test WebSocket output should carry a request id")
                        .to_owned()
                })
            })
            .collect()
    }

    fn websocket_handshake_request_ids(
        snapshot: &super::PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<String> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_websocket()
                    .and_then(|output| output.as_handshake())
                    .map(|output| output.request_id().to_owned())
            })
            .collect()
    }

    fn websocket_frame_outputs(
        snapshot: &super::PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<(String, usize)> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_websocket()
                    .and_then(|output| output.as_frame())
                    .map(|output| (output.request_id().to_owned(), output.payload_length()))
            })
            .collect()
    }

    #[test]
    fn target_artifact_reset_clears_response_bodies_and_io_streams_together() {
        let mut agent = TargetNetworkAgentState::default();

        agent.record_captured_response_body("REQ-1".to_owned(), "response body".to_owned(), [None]);
        agent.insert_io_stream("STREAM-1".to_owned(), b"stream body".to_vec(), 0);
        assert!(agent.has_captured_response_body("REQ-1"));
        assert!(!agent.io_streams_empty());

        agent.reset_all_target_scoped_artifacts();
        assert!(!agent.has_captured_response_body("REQ-1"));
        assert!(agent.io_streams_empty());
    }

    #[test]
    fn output_queue_reset_clears_page_local_subresource_request_handle_bindings() {
        let mut agent = TargetNetworkAgentState::default();
        let handle = SubresourceNetworkRequestHandle::new(5);

        agent.record_subresource_request_id_for_handle_if_absent(handle, "REQ-old".to_owned());
        agent.record_subresource_request_id_for_handle_if_absent(handle, "REQ-stale".to_owned());
        assert_eq!(
            agent
                .artifacts
                .subresource_network_artifacts
                .request_id_for_handle(handle),
            Some("REQ-old")
        );

        agent.reset_output_queue();
        agent.record_subresource_request_id_for_handle_if_absent(handle, "REQ-new".to_owned());
        assert_eq!(
            agent
                .artifacts
                .subresource_network_artifacts
                .request_id_for_handle(handle),
            Some("REQ-new")
        );
    }

    #[test]
    fn contextual_preferred_request_id_skips_earlier_unrelated_records() {
        let mut agent = TargetNetworkAgentState::default();
        let contextual_handle = SubresourceNetworkRequestHandle::new(7);
        agent.enable_primary_events();
        agent.record_subresource_request_id_for_handle_if_absent(
            contextual_handle,
            "REQ-contextual".to_owned(),
        );
        let records = [
            subresource_record("https://example.com/earlier.js"),
            subresource_record("https://example.com/contextual.js")
                .with_request_handle(contextual_handle),
        ];
        ingest_network_output(&mut agent, &records, &[]);

        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let snapshot = pending_combined_snapshot_with_allocator(
            &mut agent,
            Some("REQ-contextual"),
            &mut request_id_allocator,
        );

        assert_eq!(
            subresource_request_ids(&snapshot),
            vec!["REQ-1", "REQ-contextual"],
            "a contextual id already bound to a request handle must not be consumed by an earlier unrelated backlog record"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            1,
            "only the unrelated record should allocate a new request id"
        );
    }

    #[test]
    fn body_artifacts_own_io_stream_read_offsets_and_close() {
        let mut agent = TargetNetworkAgentState::default();
        agent.insert_io_stream("STREAM-1".to_owned(), b"abcdef".to_vec(), 0);

        let first = agent
            .read_io_stream("STREAM-1", None, Some(2))
            .expect("stream should exist");
        assert_eq!(first.bytes, b"ab");
        assert!(!first.eof);

        let second = agent
            .read_io_stream("STREAM-1", Some(4), None)
            .expect("stream should exist");
        assert_eq!(second.bytes, b"ef");
        assert!(second.eof);

        assert!(agent.close_io_stream("STREAM-1"));
        assert!(agent.read_io_stream("STREAM-1", None, None).is_none());
        assert!(!agent.close_io_stream("STREAM-1"));
    }

    #[test]
    fn body_artifacts_read_io_stream_from_captured_body_source() {
        let mut writer = CapturedBodyWriter::new(4);
        writer
            .append(b"captured body source")
            .expect("captured body writer should accept bytes");
        let body = writer
            .finish()
            .expect("captured body writer should finish source");
        let mut agent = TargetNetworkAgentState::default();

        agent.insert_io_stream_body_source("STREAM-source".to_owned(), body, 0);

        let first = agent
            .read_io_stream("STREAM-source", None, Some(8))
            .expect("source-backed stream should exist");
        assert_eq!(first.bytes, b"captured");
        assert!(!first.eof);

        let second = agent
            .read_io_stream("STREAM-source", None, None)
            .expect("source-backed stream should remain readable");
        assert_eq!(second.bytes, b" body source");
        assert!(second.eof);
    }

    #[test]
    fn websocket_request_ids_are_owned_by_network_agent() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();

        agent.record_websocket_request_id_for_socket_if_absent(7, "REQ-bound".to_owned());
        assert_eq!(
            agent.websocket_request_id_for_socket_or_allocate_with(7, &mut request_id_allocator),
            "REQ-bound"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "bound request id should not consume a new network id"
        );

        let allocated =
            agent.websocket_request_id_for_socket_or_allocate_with(8, &mut request_id_allocator);
        assert_eq!(allocated, "REQ-1");
        assert_eq!(
            agent.websocket_request_id_for_socket_or_allocate_with(8, &mut request_id_allocator),
            "REQ-1"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            1,
            "subsequent lookups should reuse the socket mapping"
        );
    }

    #[test]
    fn synthetic_websocket_request_registration_updates_reverse_socket_mapping() {
        let mut agent = TargetNetworkAgentState::default();

        agent.register_synthetic_websocket_request("FETCH-1".to_owned(), "REQ-first".to_owned(), 7);
        agent.register_synthetic_websocket_request(
            "FETCH-2".to_owned(),
            "REQ-second".to_owned(),
            7,
        );

        assert_eq!(
            agent.synthetic_websocket_socket_id_for_request("FETCH-1"),
            Some(7)
        );
        assert_eq!(
            agent.synthetic_websocket_socket_id_for_request("FETCH-2"),
            Some(7)
        );
        assert_eq!(
            agent.websocket_request_id_for_socket_or_allocate(7),
            "REQ-second",
            "re-registering a synthetic socket must keep the canonical reverse map in sync"
        );
    }

    #[test]
    fn attached_network_event_sessions_follow_enable_insertion_order() {
        let mut agent = TargetNetworkAgentState::default();

        agent.enable_attached_events("SID-z");
        agent.enable_attached_events("SID-a");
        agent.enable_attached_events("SID-z");

        assert_eq!(
            agent.event_session_ids(Some("SID-primary"), Some("SID-primary")),
            vec![Some("SID-z".to_owned()), Some("SID-a".to_owned())],
            "attached Network listeners should not be sorted by session id"
        );

        agent.enable_primary_events();
        assert_eq!(
            agent.event_session_ids(Some("SID-primary"), Some("SID-primary")),
            vec![
                Some("SID-primary".to_owned()),
                Some("SID-z".to_owned()),
                Some("SID-a".to_owned()),
            ],
            "primary listener remains first, followed by attached enable order"
        );

        assert!(agent.disable_attached_events("SID-z"));
        agent.enable_attached_events("SID-z");
        assert_eq!(
            agent.event_session_ids(Some("SID-primary"), Some("SID-primary")),
            vec![
                Some("SID-primary".to_owned()),
                Some("SID-a".to_owned()),
                Some("SID-z".to_owned()),
            ],
            "disable then re-enable should append the attached session"
        );
    }

    #[test]
    fn consecutive_renderer_live_tokens_own_disjoint_ingress_ranges() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();

        let first = ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
            subresource_record("https://example.com/first.js"),
        ));
        let second = ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
            subresource_record("https://example.com/second.js"),
        ));
        let mut first_delivery = agent.ingest_renderer_output_item_and_prepare_live_delivery(
            &first,
            "LOADER-1",
            None,
            None,
            None,
            &mut request_id_allocator,
        );
        let mut second_delivery = agent.ingest_renderer_output_item_and_prepare_live_delivery(
            &second,
            "LOADER-1",
            None,
            None,
            None,
            &mut request_id_allocator,
        );
        assert_eq!(agent.output_queue.retained_delivery_output_count(), 2);

        let first_snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut first_delivery)
            .expect("the first renderer fact should own one live delivery range");
        assert_eq!(
            subresource_urls(&first_snapshot),
            vec!["https://example.com/first.js"]
        );
        agent.mark_network_backlog_delivery_snapshot_emitted(&first_snapshot);
        assert_eq!(agent.output_queue.retained_delivery_output_count(), 1);

        let second_snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut second_delivery)
            .expect("the second renderer fact should own one live delivery range");
        assert_eq!(
            subresource_urls(&second_snapshot),
            vec!["https://example.com/second.js"],
            "a later ingress token must not rediscover an earlier unprojected fact from the session cursor"
        );
        agent.mark_network_backlog_delivery_snapshot_emitted(&second_snapshot);
        assert_eq!(agent.output_queue.retained_delivery_output_count(), 0);
        assert_eq!(
            agent
                .artifacts
                .emitted_subresource_record_count_for_session(None),
            2
        );
    }

    #[test]
    fn renderer_outputs_without_network_listeners_are_not_retained() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let item = ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
            "https://example.com/before-enable.js",
        )));

        let delivery = agent.ingest_renderer_output_item_and_prepare_live_delivery(
            &item,
            "LOADER-1",
            None,
            None,
            None,
            &mut request_id_allocator,
        );

        assert!(!delivery.has_output());
        assert_eq!(agent.output_queue.subresource_record_count(), 1);
        assert_eq!(agent.output_queue.retained_delivery_output_count(), 0);
    }

    #[test]
    fn websocket_observation_cursors_and_request_ids_are_separate_artifacts() {
        let mut artifacts = WebSocketNetworkArtifacts::default();
        artifacts.set_session_cursors(None, 3, 5);
        artifacts.set_request_id_for_socket_if_absent(7, "REQ-bound".to_owned());

        artifacts.clear_request_ids();

        assert_eq!(
            artifacts.emitted_record_count_for_session(None),
            3,
            "clearing WebSocket request ids must not reset record observation cursors"
        );
        assert_eq!(
            artifacts.emitted_event_count_for_session(None),
            5,
            "clearing WebSocket request ids must not reset frame observation cursors"
        );
        assert_eq!(artifacts.request_id_for_socket(7), None);

        artifacts.clear_all();
        assert_eq!(artifacts.emitted_record_count_for_session(None), 0);
        assert_eq!(artifacts.emitted_event_count_for_session(None), 0);
    }

    #[test]
    fn subresource_delivery_snapshot_binds_websocket_request_id() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        ingest_network_output(&mut agent, &records, &[]);
        let snapshot = pending_combined_snapshot_with_allocator(
            &mut agent,
            Some("REQ-from-subresource"),
            &mut request_id_allocator,
        );

        assert_eq!(
            subresource_request_ids(&snapshot),
            vec!["REQ-from-subresource"]
        );
        assert_eq!(
            agent.websocket_request_id_for_socket_or_allocate(7),
            "REQ-from-subresource"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "subresource output binding should not allocate a second request id"
        );
    }

    #[test]
    fn prepared_backlog_drives_delivery_snapshots_without_recomputing_ranges() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        let records = vec![
            subresource_record("https://example.com/app.js"),
            websocket_record("wss://example.com/socket", 7),
        ];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);

        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let mut backlog = agent.backlog_prepared_delivery(
            None,
            None,
            Some(contextual_preferred_request_id("REQ-main")),
            &mut request_id_allocator,
        );
        assert!(
            backlog.has_output(),
            "prepared backlog should retain one visible Network output for typed backlog items"
        );

        let snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("prepared combined backlog should build a delivery snapshot");
        assert_eq!(snapshot.outputs().len(), 4);
        assert_eq!(
            subresource_request_ids(&snapshot),
            vec!["REQ-main", "REQ-1"],
            "WebSocket subresource metadata should bind a stable owner request id while consuming prepared output"
        );
        assert_eq!(
            websocket_request_ids(&snapshot),
            vec!["REQ-1", "REQ-1"],
            "prepared WebSocket delivery should reuse the request id bound by the subresource snapshot"
        );
        assert!(
            !backlog.has_output(),
            "prepared backlog outputs should be one-shot delivery inputs"
        );
    }

    #[test]
    fn prepared_backlog_drives_combined_network_delivery_snapshot() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        let script_record = subresource_record("https://example.com/app.js");
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let fetch_record = subresource_record("https://example.com/api");
        let events = [websocket_event(7, 12)];
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(script_record)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record)),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(events[0].clone()),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(fetch_record)),
        ];
        for item in &items {
            agent.ingest_renderer_output_item(item, "LOADER-1");
        }

        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let mut backlog = agent.backlog_prepared_delivery(
            None,
            None,
            Some(contextual_preferred_request_id("REQ-main")),
            &mut request_id_allocator,
        );
        let snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("prepared network backlog should build one combined delivery snapshot");

        assert_eq!(snapshot.outputs().len(), 5);
        let output_order = snapshot
            .outputs()
            .into_iter()
            .map(|item| {
                if let Some(output) = item.as_subresource() {
                    return format!("sub:{}", output.request_id());
                }
                let output = item
                    .as_websocket()
                    .expect("combined backlog item should be subresource or WebSocket");
                if let Some(output) = output.as_handshake() {
                    format!("ws-handshake:{}", output.request_id())
                } else if let Some(output) = output.as_frame() {
                    format!("ws-frame:{}", output.request_id())
                } else {
                    unreachable!("test WebSocket item should be handshake or frame")
                }
            })
            .collect::<Vec<_>>();
        assert_eq!(
            output_order,
            vec![
                "sub:REQ-main",
                "sub:REQ-1",
                "ws-handshake:REQ-1",
                "ws-frame:REQ-1",
                "sub:REQ-2",
            ],
            "combined backlog snapshot should preserve producer delivery order across families"
        );
        let subresource_request_ids = snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| item.as_subresource().map(|output| output.request_id()))
            .collect::<Vec<_>>();
        assert_eq!(
            subresource_request_ids,
            vec!["REQ-main", "REQ-1", "REQ-2"],
            "WebSocket metadata should bind a request id before WebSocket events are materialized"
        );
        let websocket_request_ids = snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| {
                item.as_websocket().map(|output| {
                    output
                        .as_handshake()
                        .map(|output| output.request_id())
                        .or_else(|| output.as_frame().map(|output| output.request_id()))
                        .expect("test WebSocket item should carry a request id")
                })
            })
            .collect::<Vec<_>>();
        assert_eq!(
            websocket_request_ids,
            vec!["REQ-1", "REQ-1"],
            "WebSocket delivery should reuse the request id bound by subresource metadata"
        );
        assert!(
            !backlog.has_output(),
            "combined delivery snapshots should consume every prepared backlog family"
        );

        agent.mark_network_backlog_delivery_snapshot_emitted(&snapshot);
        assert!(
            !agent
                .backlog_prepared_delivery(
                    None,
                    None,
                    None,
                    &mut ConnectionNetworkRequestIdAllocator::default()
                )
                .has_output(),
            "combined mark-emitted should advance subresource and WebSocket cursors together"
        );
    }

    #[test]
    fn prepared_backlog_preserves_preferred_request_id_after_bound_websocket_metadata() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        agent.register_synthetic_websocket_request(
            "FETCH-ws".to_owned(),
            "REQ-synthetic-ws".to_owned(),
            7,
        );
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let api_record = subresource_record("https://example.com/api");
        let events = [websocket_event(7, 12)];
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record)),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(events[0].clone()),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(api_record)),
        ];
        for item in &items {
            agent.ingest_renderer_output_item(item, "LOADER-1");
        }

        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let mut backlog = agent.backlog_prepared_delivery(
            None,
            None,
            Some(contextual_preferred_request_id("REQ-main")),
            &mut request_id_allocator,
        );
        let snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("prepared network backlog should build one combined delivery snapshot");
        let output_order = snapshot
            .outputs()
            .into_iter()
            .map(|item| {
                if let Some(output) = item.as_subresource() {
                    return format!("sub:{}", output.request_id());
                }
                let output = item
                    .as_websocket()
                    .expect("combined backlog item should be subresource or WebSocket");
                if let Some(output) = output.as_handshake() {
                    format!("ws-handshake:{}", output.request_id())
                } else if let Some(output) = output.as_frame() {
                    format!("ws-frame:{}", output.request_id())
                } else {
                    unreachable!("test WebSocket item should be handshake or frame")
                }
            })
            .collect::<Vec<_>>();

        assert_eq!(
            output_order,
            vec![
                "sub:REQ-synthetic-ws",
                "ws-handshake:REQ-synthetic-ws",
                "ws-frame:REQ-synthetic-ws",
                "sub:REQ-main",
            ],
            "resolving already-bound WebSocket metadata must not consume the preferred id needed by the next ordinary subresource"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "synthetic WebSocket binding and preferred subresource id should not allocate fallback request ids"
        );
    }

    #[test]
    fn merged_prepared_backlog_preserves_preferred_request_id_after_bound_websocket_metadata() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        agent.register_synthetic_websocket_request(
            "FETCH-ws".to_owned(),
            "REQ-synthetic-ws".to_owned(),
            7,
        );
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let api_record = subresource_record("https://example.com/api");
        let events = [websocket_event(7, 12)];
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record)),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(events[0].clone()),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(api_record)),
        ];
        for item in &items {
            agent.ingest_renderer_output_item(item, "LOADER-1");
        }

        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ])
        .expect("test subresource activity should be visible");
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 0, 0),
        ])
        .expect("test websocket activity should be visible");
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        let mut request_ids = NetworkBacklogRequestIdPlan::new(
            &mut agent.artifacts.subresource_network_artifacts,
            &mut agent.artifacts.websocket_network_artifacts,
            Some(contextual_preferred_request_id("REQ-main")),
            &mut request_id_allocator,
        );
        let mut subresource_backlog = agent.output_queue.backlog_prepared_delivery_for_activity(
            Some(subresource_activity),
            None,
            &mut request_ids,
        );
        let websocket_backlog = agent.output_queue.backlog_prepared_delivery_for_activity(
            None,
            Some(websocket_activity),
            &mut request_ids,
        );
        subresource_backlog.extend(websocket_backlog);

        let snapshot = agent
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut subresource_backlog)
            .expect("merged prepared backlog should build one combined delivery snapshot");
        let output_order = snapshot
            .outputs()
            .into_iter()
            .map(|item| {
                if let Some(output) = item.as_subresource() {
                    return format!("sub:{}", output.request_id());
                }
                let output = item
                    .as_websocket()
                    .expect("combined backlog item should be subresource or WebSocket");
                if let Some(output) = output.as_handshake() {
                    format!("ws-handshake:{}", output.request_id())
                } else if let Some(output) = output.as_frame() {
                    format!("ws-frame:{}", output.request_id())
                } else {
                    unreachable!("test WebSocket item should be handshake or frame")
                }
            })
            .collect::<Vec<_>>();

        assert_eq!(
            output_order,
            vec![
                "sub:REQ-synthetic-ws",
                "ws-handshake:REQ-synthetic-ws",
                "ws-frame:REQ-synthetic-ws",
                "sub:REQ-main",
            ],
            "merged prepared tokens must preserve preferred-id availability across already-bound WebSocket metadata"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "merged synthetic WebSocket binding and preferred subresource id should not allocate fallback request ids"
        );
    }

    #[test]
    fn websocket_handshake_backlog_survives_caught_up_subresource_cursor() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        ingest_network_output(&mut agent, &records, &[]);
        let snapshot = pending_combined_snapshot(&mut agent, Some("REQ-bound"));
        assert_eq!(subresource_request_ids(&snapshot), vec!["REQ-bound"]);
        agent.mark_subresource_records_emitted(None, 0, 1);

        assert!(
            agent
                .backlog_prepared_delivery(
                    None,
                    None,
                    None,
                    &mut ConnectionNetworkRequestIdAllocator::default()
                )
                .has_output(),
            "subresource and websocket handshake cursors must remain independent"
        );
        let handshake_snapshot = pending_combined_snapshot(&mut agent, None);
        assert_eq!(
            websocket_handshake_request_ids(&handshake_snapshot),
            vec!["REQ-bound"]
        );
        agent.mark_network_backlog_delivery_snapshot_emitted(&handshake_snapshot);
        assert!(
            !agent
                .backlog_prepared_delivery(
                    None,
                    None,
                    None,
                    &mut ConnectionNetworkRequestIdAllocator::default()
                )
                .has_output()
        );
    }

    #[test]
    fn websocket_frame_backlog_survives_caught_up_handshake_cursor() {
        let mut agent = TargetNetworkAgentState::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);
        let handshake_snapshot = pending_combined_snapshot(&mut agent, None);
        assert_eq!(
            websocket_handshake_request_ids(&handshake_snapshot),
            vec!["REQ-1"]
        );
        agent.mark_websocket_activity_emitted(None, 0, 1, 0, 0);

        assert!(
            agent
                .backlog_prepared_delivery(
                    None,
                    None,
                    None,
                    &mut ConnectionNetworkRequestIdAllocator::default()
                )
                .has_output(),
            "handshake cursor must not consume subresource or frame backlog"
        );
        let frame_snapshot = pending_combined_snapshot(&mut agent, None);
        assert!(
            websocket_handshake_request_ids(&frame_snapshot).is_empty(),
            "handshake cursor should hide handshake output from the next combined snapshot"
        );
        assert_eq!(
            websocket_frame_outputs(&frame_snapshot),
            vec![("REQ-1".to_owned(), 12)]
        );
        agent.mark_network_backlog_delivery_snapshot_emitted(&frame_snapshot);
        assert!(
            !agent
                .backlog_prepared_delivery(
                    None,
                    None,
                    None,
                    &mut ConnectionNetworkRequestIdAllocator::default()
                )
                .has_output(),
            "combined mark should consume the remaining subresource and frame outputs together"
        );
    }

    #[test]
    fn websocket_subresource_delivery_reuses_existing_socket_request_id() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);
        let handshake_snapshot =
            pending_combined_snapshot_with_allocator(&mut agent, None, &mut request_id_allocator);
        assert_eq!(
            websocket_handshake_request_ids(&handshake_snapshot),
            vec!["REQ-1"]
        );

        assert_eq!(
            subresource_request_ids(&handshake_snapshot),
            vec!["REQ-1"],
            "websocket subresource delivery must reuse the socket request id instead of inventing a second id"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            1,
            "reusing the existing socket request id should not allocate a second request id"
        );
        assert_eq!(
            websocket_frame_outputs(&handshake_snapshot),
            vec![("REQ-1".to_owned(), 12)]
        );
    }

    #[test]
    fn combined_frame_delivery_prefers_visible_subresource_binding() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);

        agent.mark_websocket_activity_emitted(None, 0, 1, 0, 0);

        let frame_snapshot = pending_combined_snapshot_with_allocator(
            &mut agent,
            Some("REQ-preferred"),
            &mut request_id_allocator,
        );
        assert!(
            websocket_handshake_request_ids(&frame_snapshot).is_empty(),
            "record cursor should hide handshake output from the combined snapshot"
        );
        assert_eq!(
            websocket_frame_outputs(&frame_snapshot),
            vec![("REQ-preferred".to_owned(), 12)],
            "combined delivery should let the still-visible subresource metadata bind the socket before the frame is materialized"
        );
        assert_eq!(
            subresource_request_ids(&frame_snapshot),
            vec!["REQ-preferred"],
            "visible subresource metadata owns the request id binding in the combined production path"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "preferred subresource binding should not allocate a synthetic WebSocket request id"
        );
    }

    #[test]
    fn frame_only_delivery_does_not_consume_preferred_subresource_request_id() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let api_record = subresource_record("https://example.com/api");
        let events = [websocket_event(7, 12)];
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record)),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(events[0].clone()),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(api_record)),
        ];
        for item in &items {
            agent.ingest_renderer_output_item(item, "LOADER-1");
        }

        agent.mark_subresource_records_emitted(None, 0, 1);
        agent.mark_websocket_activity_emitted(None, 0, 1, 0, 0);

        let frame_snapshot = pending_combined_snapshot_with_allocator(
            &mut agent,
            Some("REQ-preferred"),
            &mut request_id_allocator,
        );
        assert!(
            websocket_handshake_request_ids(&frame_snapshot).is_empty(),
            "handshake cursor should hide the WebSocket handshake output"
        );
        assert_eq!(
            websocket_frame_outputs(&frame_snapshot),
            vec![("REQ-1".to_owned(), 12)],
            "frame-only delivery should allocate a socket request id instead of consuming the preferred subresource id"
        );
        assert_eq!(
            subresource_request_ids(&frame_snapshot),
            vec!["REQ-preferred"],
            "the later ordinary subresource should still consume the preferred request id"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            1,
            "only the frame-only WebSocket path should allocate a fallback request id"
        );
    }

    #[test]
    fn websocket_delivery_snapshots_resolve_request_ids_in_network_agent() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);
        assert_eq!(
            subresource_request_ids(&pending_combined_snapshot_with_allocator(
                &mut agent,
                Some("REQ-bound"),
                &mut request_id_allocator
            )),
            vec!["REQ-bound"],
            "subresource delivery should bind the preferred request id"
        );
        let snapshot =
            pending_combined_snapshot_with_allocator(&mut agent, None, &mut request_id_allocator);
        assert_eq!(
            websocket_handshake_request_ids(&snapshot),
            vec!["REQ-bound"],
            "handshake delivery should reuse the subresource request id"
        );
        assert_eq!(
            websocket_frame_outputs(&snapshot),
            vec![("REQ-bound".to_owned(), 12)],
            "frame delivery should reuse the same owner-resolved request id"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            0,
            "delivery snapshots should not allocate when subresource binding exists"
        );
    }

    #[test]
    fn websocket_delivery_snapshots_allocate_unbound_socket_request_id_once() {
        let mut agent = TargetNetworkAgentState::default();
        let mut request_id_allocator = ConnectionNetworkRequestIdAllocator::default();
        agent.enable_primary_events();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = [websocket_event(7, 12)];
        ingest_network_output(&mut agent, &records, &events);

        assert_eq!(
            websocket_handshake_request_ids(&pending_combined_snapshot_with_allocator(
                &mut agent,
                None,
                &mut request_id_allocator
            )),
            vec!["REQ-1"],
            "unbound handshake delivery should allocate a request id"
        );
        assert_eq!(request_id_allocator.next_sequence_for_test(), 1);

        assert_eq!(
            websocket_frame_outputs(&pending_combined_snapshot_with_allocator(
                &mut agent,
                None,
                &mut request_id_allocator
            )),
            vec![("REQ-1".to_owned(), 12)],
            "frame delivery should reuse the request id allocated for the same socket"
        );
        assert_eq!(
            request_id_allocator.next_sequence_for_test(),
            1,
            "frame delivery should not allocate another request id for the same socket"
        );
    }
}