Skip to content

armgit / moli

Public Imported from GitHub
0

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

203 KB
Raw Blame
use moli_cookie_jar::{StoredCookieQueryReport, StoredCookieSetReport};
use moli_core::page::{
    NavigationRedirect, ScriptNetworkOutputItem, SubresourceBodyFinished,
    SubresourceBodyFinishedResult, SubresourceDataReceived, SubresourceEventSourceMessageReceived,
    SubresourceNetworkOutcome, SubresourceNetworkRecord, SubresourceNetworkRequestHandle,
    SubresourceRequestInitiatorType, SubresourceRequestStarted, SubresourceResourceType,
    SubresourceResponseBody, SubresourceResponseStarted, WebSocketFrameDirection,
    WebSocketFrameOpcode, WebSocketLifecycleEvent, WebSocketLifecycleKind, WebSocketNetworkEvent,
};
use moli_fetch::NegotiatedHttpVersion;
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::Arc;
use url::Url;

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct TargetNetworkOutputQueue {
    queue_generation: u64,
    subresource_record_count: usize,
    websocket_event_count: usize,
    next_delivery_order_index: usize,
    completed_subresource_handles: HashSet<SubresourceNetworkRequestHandle>,
    websocket_handshake_recorded_socket_ids: HashSet<u64>,
    pending_websocket_lifecycle_events: HashMap<u64, Vec<WebSocketLifecycleEvent>>,
    staged_subresource_requests:
        HashMap<SubresourceNetworkRequestHandle, Arc<TargetSubresourceRequestStartedOutput>>,
    staged_subresource_responses:
        HashMap<SubresourceNetworkRequestHandle, Arc<TargetSubresourceResponseStartedOutput>>,
    delivery_outputs: TargetNetworkDeliveryOutputQueue,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub(crate) struct TargetNetworkBacklogPreparedDelivery {
    delivery: Option<TargetNetworkBacklogDeliveryToken>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetNetworkBacklogDeliveryToken {
    queue_generation: u64,
    families: TargetNetworkBacklogPreparedFamilies,
    entries: Vec<PendingNetworkBacklogDeliveryEntry>,
    cursor_advances: PendingNetworkBacklogCursorAdvances,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct TargetNetworkBacklogPreparedDeliveryBatch {
    families: TargetNetworkBacklogPreparedFamilies,
    entries: Vec<PendingNetworkBacklogDeliveryEntry>,
    cursor_advances: PendingNetworkBacklogCursorAdvances,
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
struct TargetNetworkBacklogPreparedFamilies {
    subresource: bool,
    websocket: bool,
}

#[cfg(test)]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub(crate) struct TargetNetworkBacklogActivityCursor {
    subresource_record_start_index: Option<usize>,
    websocket_record_start_index: Option<usize>,
    websocket_event_start_index: Option<usize>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq)]
struct TargetNetworkDeliveryOutputQueue {
    outputs: VecDeque<TargetNetworkDeliveryOutputItem>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetNetworkDeliveryOutputItem {
    subresource_record_tail_after_item: usize,
    websocket_record_tail_after_item: usize,
    websocket_event_tail_after_item: usize,
    output: TargetNetworkDeliveryOutput,
}

#[derive(Clone, Debug, Eq, PartialEq)]
enum TargetNetworkDeliveryOutput {
    Subresource(Box<TargetSubresourcePlanOutput>),
    WebSocket(TargetWebSocketDeliveryOutput),
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetWebSocketDeliveryOutput {
    source: TargetWebSocketDeliveryOutputSource,
    record: TargetWebSocketDeliveryPlanRecord,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetWebSocketHandshakePlanOutput {
    delivery_order_index: usize,
    socket_id: u64,
    handshake: TargetWebSocketHandshakePlanPayload,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetWebSocketHandshakePlanPayload {
    index: usize,
    url: Url,
    request_headers: Vec<(String, String)>,
    response: Option<TargetWebSocketHandshakeResponseOutput>,
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum TargetWebSocketDeliveryOutputSource {
    Handshake { record_index: usize },
    Frame { event_index: usize },
    Lifecycle { event_index: usize },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingSubresourceNetworkActivity {
    sessions: Vec<PendingSubresourceNetworkActivitySession>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingSubresourceNetworkActivitySession {
    session_id: Option<String>,
    start_index: usize,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingWebSocketNetworkActivity {
    sessions: Vec<PendingWebSocketNetworkActivitySession>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingWebSocketNetworkActivitySession {
    session_id: Option<String>,
    record_start_index: usize,
    event_start_index: usize,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct PendingNetworkBacklogDeliverySnapshot {
    entries: Vec<PendingNetworkBacklogDeliveryEntry>,
    cursor_advances: PendingNetworkBacklogCursorAdvances,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingSubresourceNetworkCursorAdvance {
    session_id: Option<String>,
    start_index: usize,
    record_count: usize,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PendingWebSocketNetworkCursorAdvance {
    session_id: Option<String>,
    record_start_index: usize,
    record_count: usize,
    event_start_index: usize,
    event_count: usize,
}

#[derive(Debug, Clone, Default, PartialEq, Eq)]
struct PendingNetworkBacklogCursorAdvances {
    subresource: Vec<PendingSubresourceNetworkCursorAdvance>,
    websocket: Vec<PendingWebSocketNetworkCursorAdvance>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum PendingNetworkBacklogDeliveryItem {
    Subresource(Box<TargetSubresourceNetworkDeliveryOutput>),
    WebSocket(TargetWebSocketDeliveryRecord),
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct PendingNetworkBacklogDeliveryEntry {
    item: PendingNetworkBacklogDeliveryItem,
    session_ids: Vec<Option<String>>,
}

pub(crate) trait TargetNetworkBacklogRequestIdResolver {
    fn request_id_for_subresource_output(&mut self, output: &TargetSubresourcePlanOutput)
    -> String;

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

impl TargetNetworkBacklogPreparedDelivery {
    pub(crate) fn extend(&mut self, other: Self) {
        let Some(other_delivery) = other.delivery else {
            return;
        };
        if let Some(delivery) = self.delivery.as_mut() {
            if delivery.queue_generation == other_delivery.queue_generation {
                delivery.extend(other_delivery);
            } else if other_delivery.queue_generation > delivery.queue_generation {
                self.delivery = Some(other_delivery);
            }
        } else {
            self.delivery = Some(other_delivery);
        }
    }

    pub(crate) fn has_delivery_output(&self) -> bool {
        self.delivery
            .as_ref()
            .is_some_and(TargetNetworkBacklogDeliveryToken::has_items)
    }

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

    fn take_delivery_token(&mut self) -> Option<TargetNetworkBacklogDeliveryToken> {
        self.delivery.take()
    }

    fn push_batch(
        &mut self,
        queue_generation: u64,
        batch: TargetNetworkBacklogPreparedDeliveryBatch,
    ) {
        if !batch.has_items() {
            return;
        }
        self.delivery_mut(queue_generation).push_batch(batch);
    }

    fn delivery_mut(&mut self, queue_generation: u64) -> &mut TargetNetworkBacklogDeliveryToken {
        self.delivery
            .get_or_insert_with(|| TargetNetworkBacklogDeliveryToken::new(queue_generation))
    }
}

impl TargetNetworkBacklogDeliveryToken {
    fn new(queue_generation: u64) -> Self {
        Self {
            queue_generation,
            families: TargetNetworkBacklogPreparedFamilies::default(),
            entries: Vec::new(),
            cursor_advances: PendingNetworkBacklogCursorAdvances::default(),
        }
    }

    fn extend(&mut self, other: Self) {
        if self.queue_generation != other.queue_generation {
            return;
        }
        let Self {
            queue_generation: _,
            families,
            entries,
            cursor_advances,
        } = other;
        let (subresource_entries, websocket_entries): (Vec<_>, Vec<_>) = entries
            .into_iter()
            .partition(PendingNetworkBacklogDeliveryEntry::is_subresource);
        let PendingNetworkBacklogCursorAdvances {
            subresource,
            websocket,
        } = cursor_advances;

        if families.subresource && self.families.push_subresource_if_absent() {
            self.entries.extend(subresource_entries);
            self.cursor_advances.subresource.extend(subresource);
        }
        if families.websocket && self.families.push_websocket_if_absent() {
            self.entries.extend(websocket_entries);
            self.cursor_advances.websocket.extend(websocket);
        }
        self.sort_entries();
    }

    fn matches_generation(&self, queue_generation: u64) -> bool {
        self.queue_generation == queue_generation
    }

    fn into_parts(
        self,
    ) -> (
        Vec<PendingNetworkBacklogDeliveryEntry>,
        PendingNetworkBacklogCursorAdvances,
    ) {
        (self.entries, self.cursor_advances)
    }

    fn push_batch(&mut self, batch: TargetNetworkBacklogPreparedDeliveryBatch) {
        let TargetNetworkBacklogPreparedDeliveryBatch {
            families,
            mut entries,
            cursor_advances,
        } = batch;
        let accept_subresource = families.subresource && self.families.push_subresource_if_absent();
        let accept_websocket = families.websocket && self.families.push_websocket_if_absent();
        if !accept_subresource && !accept_websocket {
            return;
        }
        let had_entries = !self.entries.is_empty();
        entries.sort_by_key(PendingNetworkBacklogDeliveryEntry::delivery_order_index);
        let PendingNetworkBacklogCursorAdvances {
            subresource,
            websocket,
        } = cursor_advances;
        match (accept_subresource, accept_websocket) {
            (true, true) => {
                self.entries.extend(entries);
                self.cursor_advances.subresource.extend(subresource);
                self.cursor_advances.websocket.extend(websocket);
            }
            (true, false) => {
                self.entries.extend(
                    entries
                        .into_iter()
                        .filter(PendingNetworkBacklogDeliveryEntry::is_subresource),
                );
                self.cursor_advances.subresource.extend(subresource);
            }
            (false, true) => {
                self.entries
                    .extend(entries.into_iter().filter(|entry| !entry.is_subresource()));
                self.cursor_advances.websocket.extend(websocket);
            }
            (false, false) => {}
        }
        if had_entries {
            self.sort_entries();
        }
    }

    fn has_items(&self) -> bool {
        !self.entries.is_empty()
    }

    fn sort_entries(&mut self) {
        self.entries
            .sort_by_key(PendingNetworkBacklogDeliveryEntry::delivery_order_index);
    }
}

impl TargetNetworkBacklogPreparedDeliveryBatch {
    fn push_subresource_entry(&mut self, entry: PendingNetworkBacklogDeliveryEntry) {
        self.families.subresource = true;
        self.entries.push(entry);
    }

    fn push_websocket_entry(&mut self, entry: PendingNetworkBacklogDeliveryEntry) {
        self.families.websocket = true;
        self.entries.push(entry);
    }

    fn extend_subresource_cursor_advances(
        &mut self,
        cursor_advances: Vec<PendingSubresourceNetworkCursorAdvance>,
    ) {
        self.cursor_advances.subresource.extend(cursor_advances);
    }

    fn extend_websocket_cursor_advances(
        &mut self,
        cursor_advances: Vec<PendingWebSocketNetworkCursorAdvance>,
    ) {
        self.cursor_advances.websocket.extend(cursor_advances);
    }

    fn has_subresource_items(&self) -> bool {
        self.families.subresource
    }

    fn has_websocket_items(&self) -> bool {
        self.families.websocket
    }

    fn has_items(&self) -> bool {
        !self.entries.is_empty()
    }
}

impl TargetNetworkBacklogPreparedFamilies {
    fn push_subresource_if_absent(&mut self) -> bool {
        if self.subresource {
            return false;
        }
        self.subresource = true;
        true
    }

    fn push_websocket_if_absent(&mut self) -> bool {
        if self.websocket {
            return false;
        }
        self.websocket = true;
        true
    }
}

#[cfg(test)]
impl TargetNetworkBacklogActivityCursor {
    pub(crate) fn new(
        subresource_record_start_index: Option<usize>,
        websocket_record_start_index: Option<usize>,
        websocket_event_start_index: Option<usize>,
    ) -> Self {
        Self {
            subresource_record_start_index,
            websocket_record_start_index,
            websocket_event_start_index,
        }
    }
}

#[cfg(test)]
struct TargetNetworkBacklogTestRequestIds;

#[cfg(test)]
impl TargetNetworkBacklogRequestIdResolver for TargetNetworkBacklogTestRequestIds {
    fn request_id_for_subresource_output(
        &mut self,
        output: &TargetSubresourcePlanOutput,
    ) -> String {
        output
            .websocket_socket_id()
            .map(|socket_id| format!("REQ-{socket_id}"))
            .unwrap_or_else(|| format!("REQ-{}", output.index() + 1))
    }

    fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
        format!("REQ-{socket_id}")
    }
}

impl TargetNetworkDeliveryOutputQueue {
    fn push_subresource(&mut self, output: TargetSubresourcePlanOutput) {
        self.push_output(TargetNetworkDeliveryOutput::Subresource(Box::new(output)));
    }

    fn push_handshake_output_if_websocket(
        &mut self,
        delivery_order_index: usize,
        index: usize,
        record: &SubresourceNetworkRecord,
    ) -> bool {
        let Some(record) = TargetWebSocketHandshakePlanOutput::from_subresource_record(
            delivery_order_index,
            index,
            record,
        ) else {
            return false;
        };
        self.push_output(TargetNetworkDeliveryOutput::WebSocket(
            TargetWebSocketDeliveryOutput::new(
                TargetWebSocketDeliveryOutputSource::Handshake {
                    record_index: index,
                },
                TargetWebSocketDeliveryPlanRecord::Handshake(record),
            ),
        ));
        true
    }

    fn prepared_delivery_batch_for_activity(
        &self,
        subresource_activity: Option<PendingSubresourceNetworkActivity>,
        websocket_activity: Option<PendingWebSocketNetworkActivity>,
        subresource_record_end_index: usize,
        websocket_event_end_index: usize,
        request_ids: &mut impl TargetNetworkBacklogRequestIdResolver,
    ) -> TargetNetworkBacklogPreparedDeliveryBatch {
        if subresource_activity.is_none() && websocket_activity.is_none() {
            return TargetNetworkBacklogPreparedDeliveryBatch::default();
        }
        let subresource_record_start_index = subresource_activity
            .as_ref()
            .map(PendingSubresourceNetworkActivity::min_start_index);
        let websocket_record_start_index = websocket_activity
            .as_ref()
            .map(PendingWebSocketNetworkActivity::min_record_start_index);
        let websocket_event_start_index = websocket_activity
            .as_ref()
            .map(PendingWebSocketNetworkActivity::min_event_start_index);
        let mut emitted_subresource_record_end =
            subresource_record_start_index.unwrap_or(subresource_record_end_index);
        let mut emitted_websocket_record_end =
            websocket_record_start_index.unwrap_or(subresource_record_end_index);
        let mut emitted_websocket_event_end =
            websocket_event_start_index.unwrap_or(websocket_event_end_index);
        let mut batch = TargetNetworkBacklogPreparedDeliveryBatch::default();
        for item in self
            .outputs
            .iter()
            .skip(self.first_output_position_for_activity(
                subresource_record_start_index,
                websocket_record_start_index,
                websocket_event_start_index,
            ))
        {
            match item.output() {
                TargetNetworkDeliveryOutput::Subresource(output) => {
                    let output = output.as_ref();
                    let Some(activity) = subresource_activity.as_ref() else {
                        continue;
                    };
                    if !is_index_visible_between(
                        output.index(),
                        activity.min_start_index(),
                        subresource_record_end_index,
                    ) {
                        continue;
                    }
                    emitted_subresource_record_end =
                        emitted_subresource_record_end.max(output.index().saturating_add(1));
                    let output = output.clone();
                    let session_ids = activity.session_ids_for_record_index(output.index());
                    let request_id = request_ids.request_id_for_subresource_output(&output);
                    batch.push_subresource_entry(PendingNetworkBacklogDeliveryEntry::new(
                        PendingNetworkBacklogDeliveryItem::Subresource(Box::new(
                            output.into_delivery_output(request_id),
                        )),
                        session_ids,
                    ));
                }
                TargetNetworkDeliveryOutput::WebSocket(output) => {
                    let Some(activity) = websocket_activity.as_ref() else {
                        continue;
                    };
                    let source = output.source();
                    if !source.is_visible_between(
                        activity.min_record_start_index(),
                        subresource_record_end_index,
                        activity.min_event_start_index(),
                        websocket_event_end_index,
                    ) {
                        continue;
                    }
                    emitted_websocket_record_end =
                        emitted_websocket_record_end.max(source.emitted_record_end());
                    emitted_websocket_event_end =
                        emitted_websocket_event_end.max(source.emitted_event_end());
                    let record = output.record();
                    let request_id =
                        request_ids.request_id_for_websocket_socket(record.socket_id());
                    let item = PendingNetworkBacklogDeliveryItem::WebSocket(
                        record.clone().into_delivery_record(request_id),
                    );
                    batch.push_websocket_entry(
                        PendingNetworkBacklogDeliveryEntry::from_websocket_item(item, activity),
                    );
                }
            }
        }
        if batch.has_subresource_items() {
            let activity = subresource_activity
                .as_ref()
                .expect("subresource batch items require subresource activity");
            batch.extend_subresource_cursor_advances(
                activity.cursor_advances_to(emitted_subresource_record_end),
            );
        }
        if batch.has_websocket_items() {
            let activity = websocket_activity
                .as_ref()
                .expect("WebSocket batch items require WebSocket activity");
            batch.extend_websocket_cursor_advances(
                activity
                    .cursor_advances_to(emitted_websocket_record_end, emitted_websocket_event_end),
            );
        }
        batch
    }

    fn push_frame_from_page_event(
        &mut self,
        delivery_order_index: usize,
        index: usize,
        event: &WebSocketNetworkEvent,
        subresource_record_count: usize,
    ) {
        self.push_output(TargetNetworkDeliveryOutput::WebSocket(
            TargetWebSocketDeliveryOutput::new(
                TargetWebSocketDeliveryOutputSource::Frame { event_index: index },
                TargetWebSocketDeliveryPlanRecord::Frame(
                    TargetWebSocketFrameOutput::from_page_event(
                        delivery_order_index,
                        index,
                        event,
                        subresource_record_count,
                    ),
                ),
            ),
        ));
    }

    fn push_lifecycle_from_page_event(
        &mut self,
        delivery_order_index: usize,
        index: usize,
        event: &WebSocketLifecycleEvent,
        subresource_record_count: usize,
    ) -> bool {
        let Some(output) = TargetWebSocketLifecycleOutput::from_page_event(
            delivery_order_index,
            index,
            event,
            subresource_record_count,
        ) else {
            return false;
        };
        self.push_output(TargetNetworkDeliveryOutput::WebSocket(
            TargetWebSocketDeliveryOutput::new(
                TargetWebSocketDeliveryOutputSource::Lifecycle { event_index: index },
                TargetWebSocketDeliveryPlanRecord::Lifecycle(output),
            ),
        ));
        true
    }

    fn push_output(&mut self, output: TargetNetworkDeliveryOutput) {
        let subresource_record_tail_after_item = self
            .subresource_record_tail()
            .max(output.emitted_subresource_record_end());
        let websocket_record_tail_after_item = self
            .websocket_record_tail()
            .max(output.emitted_websocket_record_end());
        let websocket_event_tail_after_item = self
            .websocket_event_tail()
            .max(output.emitted_websocket_event_end());
        self.outputs.push_back(TargetNetworkDeliveryOutputItem::new(
            subresource_record_tail_after_item,
            websocket_record_tail_after_item,
            websocket_event_tail_after_item,
            output,
        ));
    }

    fn discard_observed_outputs(
        &mut self,
        subresource_record_cursor: usize,
        websocket_record_cursor: usize,
        websocket_event_cursor: usize,
    ) {
        while self
            .outputs
            .front()
            .is_some_and(|item| match item.output() {
                TargetNetworkDeliveryOutput::Subresource(output) => {
                    output.index() < subresource_record_cursor
                }
                TargetNetworkDeliveryOutput::WebSocket(output) => match output.source() {
                    TargetWebSocketDeliveryOutputSource::Handshake { record_index } => {
                        record_index < websocket_record_cursor
                    }
                    TargetWebSocketDeliveryOutputSource::Frame { event_index }
                    | TargetWebSocketDeliveryOutputSource::Lifecycle { event_index } => {
                        event_index < websocket_event_cursor
                    }
                },
            })
        {
            self.outputs.pop_front();
        }
    }

    fn first_output_position_for_activity(
        &self,
        subresource_record_start_index: Option<usize>,
        websocket_record_start_index: Option<usize>,
        websocket_event_start_index: Option<usize>,
    ) -> usize {
        self.outputs.partition_point(|item| {
            subresource_record_start_index
                .is_none_or(|start_index| item.subresource_record_tail_after_item() <= start_index)
                && websocket_record_start_index.is_none_or(|start_index| {
                    item.websocket_record_tail_after_item() <= start_index
                })
                && websocket_event_start_index
                    .is_none_or(|start_index| item.websocket_event_tail_after_item() <= start_index)
        })
    }

    fn subresource_record_tail(&self) -> usize {
        self.outputs
            .back()
            .map(TargetNetworkDeliveryOutputItem::subresource_record_tail_after_item)
            .unwrap_or(0)
    }

    fn websocket_record_tail(&self) -> usize {
        self.outputs
            .back()
            .map(TargetNetworkDeliveryOutputItem::websocket_record_tail_after_item)
            .unwrap_or(0)
    }

    fn websocket_event_tail(&self) -> usize {
        self.outputs
            .back()
            .map(TargetNetworkDeliveryOutputItem::websocket_event_tail_after_item)
            .unwrap_or(0)
    }

    #[cfg(test)]
    fn subresource_outputs_from(&self, start_index: usize) -> Vec<TargetSubresourceMetadataOutput> {
        self.outputs
            .iter()
            .skip(self.first_output_position_for_activity(Some(start_index), None, None))
            .filter_map(TargetNetworkDeliveryOutputItem::subresource_output)
            .filter(|output| output.index() >= start_index)
            .cloned()
            .collect()
    }

    #[cfg(test)]
    fn websocket_records(&self) -> impl Iterator<Item = &TargetWebSocketDeliveryPlanRecord> {
        self.outputs.iter().filter_map(|item| match item.output() {
            TargetNetworkDeliveryOutput::Subresource(_) => None,
            TargetNetworkDeliveryOutput::WebSocket(output) => Some(output.record()),
        })
    }

    #[cfg(test)]
    fn websocket_sources(&self) -> impl Iterator<Item = TargetWebSocketDeliveryOutputSource> + '_ {
        self.outputs.iter().filter_map(|item| match item.output() {
            TargetNetworkDeliveryOutput::Subresource(_) => None,
            TargetNetworkDeliveryOutput::WebSocket(output) => Some(output.source()),
        })
    }

    #[cfg(test)]
    fn websocket_frame_outputs_from(&self, start_index: usize) -> Vec<TargetWebSocketFrameOutput> {
        self.websocket_records()
            .filter_map(|record| match record {
                TargetWebSocketDeliveryPlanRecord::Frame(output)
                    if output.index() >= start_index =>
                {
                    Some(output.clone())
                }
                _ => None,
            })
            .collect()
    }

    #[cfg(test)]
    fn subresource_output_mut(
        &mut self,
        record_index: usize,
    ) -> Option<&mut TargetSubresourceMetadataOutput> {
        self.outputs.iter_mut().find_map(|item| {
            let TargetNetworkDeliveryOutput::Subresource(output) = item.output_mut() else {
                return None;
            };
            (output.index() == record_index)
                .then(|| output.as_complete_mut())
                .flatten()
        })
    }

    #[cfg(test)]
    fn websocket_record_mut(
        &mut self,
        position: usize,
    ) -> Option<&mut TargetWebSocketDeliveryPlanRecord> {
        self.outputs
            .iter_mut()
            .filter_map(|item| match item.output_mut() {
                TargetNetworkDeliveryOutput::Subresource(_) => None,
                TargetNetworkDeliveryOutput::WebSocket(output) => Some(output.record_mut()),
            })
            .nth(position)
    }
}

impl TargetNetworkDeliveryOutputItem {
    fn new(
        subresource_record_tail_after_item: usize,
        websocket_record_tail_after_item: usize,
        websocket_event_tail_after_item: usize,
        output: TargetNetworkDeliveryOutput,
    ) -> Self {
        Self {
            subresource_record_tail_after_item,
            websocket_record_tail_after_item,
            websocket_event_tail_after_item,
            output,
        }
    }

    fn subresource_record_tail_after_item(&self) -> usize {
        self.subresource_record_tail_after_item
    }

    fn websocket_record_tail_after_item(&self) -> usize {
        self.websocket_record_tail_after_item
    }

    fn websocket_event_tail_after_item(&self) -> usize {
        self.websocket_event_tail_after_item
    }

    fn output(&self) -> &TargetNetworkDeliveryOutput {
        &self.output
    }

    #[cfg(test)]
    fn output_mut(&mut self) -> &mut TargetNetworkDeliveryOutput {
        &mut self.output
    }

    #[cfg(test)]
    fn subresource_output(&self) -> Option<&TargetSubresourceMetadataOutput> {
        match self.output() {
            TargetNetworkDeliveryOutput::Subresource(output) => output.as_complete(),
            TargetNetworkDeliveryOutput::WebSocket(_) => None,
        }
    }
}

impl TargetNetworkDeliveryOutput {
    fn emitted_subresource_record_end(&self) -> usize {
        match self {
            Self::Subresource(output) => output.index().saturating_add(1),
            Self::WebSocket(_) => 0,
        }
    }

    fn emitted_websocket_record_end(&self) -> usize {
        match self {
            Self::Subresource(_) => 0,
            Self::WebSocket(output) => output.source().emitted_record_end(),
        }
    }

    fn emitted_websocket_event_end(&self) -> usize {
        match self {
            Self::Subresource(_) => 0,
            Self::WebSocket(output) => output.source().emitted_event_end(),
        }
    }
}

impl TargetWebSocketDeliveryOutput {
    fn new(
        source: TargetWebSocketDeliveryOutputSource,
        record: TargetWebSocketDeliveryPlanRecord,
    ) -> Self {
        Self { source, record }
    }

    fn source(&self) -> TargetWebSocketDeliveryOutputSource {
        self.source
    }

    fn record(&self) -> &TargetWebSocketDeliveryPlanRecord {
        &self.record
    }

    #[cfg(test)]
    fn record_mut(&mut self) -> &mut TargetWebSocketDeliveryPlanRecord {
        &mut self.record
    }
}

impl TargetWebSocketDeliveryOutputSource {
    fn is_visible_between(
        self,
        record_start_index: usize,
        record_end_index: usize,
        event_start_index: usize,
        event_end_index: usize,
    ) -> bool {
        match self {
            Self::Handshake { record_index } => {
                record_start_index <= record_index && record_index < record_end_index
            }
            Self::Frame { event_index } | Self::Lifecycle { event_index } => {
                event_start_index <= event_index && event_index < event_end_index
            }
        }
    }

    fn emitted_record_end(self) -> usize {
        match self {
            Self::Handshake { record_index } => record_index.saturating_add(1),
            Self::Frame { .. } | Self::Lifecycle { .. } => 0,
        }
    }

    fn emitted_event_end(self) -> usize {
        match self {
            Self::Handshake { .. } => 0,
            Self::Frame { event_index } | Self::Lifecycle { event_index } => {
                event_index.saturating_add(1)
            }
        }
    }
}

impl TargetWebSocketHandshakePlanOutput {
    fn from_subresource_record(
        delivery_order_index: usize,
        index: usize,
        record: &SubresourceNetworkRecord,
    ) -> Option<Self> {
        if record.resource_type() != SubresourceResourceType::WebSocket {
            return None;
        }
        let socket_id = record.websocket_socket_id()?;
        Some(Self {
            delivery_order_index,
            socket_id,
            handshake: TargetWebSocketHandshakePlanPayload::from_subresource_record(index, record),
        })
    }
}

impl TargetWebSocketHandshakePlanPayload {
    fn from_subresource_record(index: usize, record: &SubresourceNetworkRecord) -> Self {
        let response = match record.outcome() {
            SubresourceNetworkOutcome::Success {
                status,
                response_headers,
                ..
            } => Some(TargetWebSocketHandshakeResponseOutput {
                status: *status,
                response_headers: response_headers.clone(),
            }),
            SubresourceNetworkOutcome::Failure { .. } => None,
        };
        Self {
            index,
            url: record.url().clone(),
            request_headers: record.request_headers().to_byte_strings(),
            response,
        }
    }
}

impl PendingNetworkBacklogDeliverySnapshot {
    fn from_delivery_entries(
        mut entries: Vec<PendingNetworkBacklogDeliveryEntry>,
        cursor_advances: PendingNetworkBacklogCursorAdvances,
    ) -> Option<Self> {
        entries.sort_by_key(PendingNetworkBacklogDeliveryEntry::delivery_order_index);
        (!entries.is_empty()).then_some(Self {
            entries,
            cursor_advances,
        })
    }

    #[cfg(test)]
    pub(crate) fn outputs(&self) -> Vec<&PendingNetworkBacklogDeliveryItem> {
        self.entries.iter().map(|entry| &entry.item).collect()
    }

    pub(crate) fn delivery_entries(
        &self,
    ) -> impl Iterator<Item = (&PendingNetworkBacklogDeliveryItem, &[Option<String>])> {
        self.entries
            .iter()
            .map(|entry| (&entry.item, entry.session_ids.as_slice()))
    }

    #[cfg(test)]
    pub(crate) fn subresource_session_ids_for_record_index(
        &self,
        record_index: usize,
    ) -> Vec<Option<String>> {
        self.entries
            .iter()
            .find_map(|entry| {
                (entry.item.subresource_record_index() == Some(record_index))
                    .then(|| entry.session_ids.clone())
            })
            .unwrap_or_default()
    }

    #[cfg(test)]
    pub(crate) fn websocket_session_ids_for_record_index(
        &self,
        record_index: usize,
    ) -> Vec<Option<String>> {
        self.entries
            .iter()
            .find_map(|entry| {
                (entry.item.websocket_record_index() == Some(record_index))
                    .then(|| entry.session_ids.clone())
            })
            .unwrap_or_default()
    }

    #[cfg(test)]
    pub(crate) fn websocket_session_ids_for_event_index(
        &self,
        event_index: usize,
    ) -> Vec<Option<String>> {
        self.entries
            .iter()
            .find_map(|entry| {
                (entry.item.websocket_event_index() == Some(event_index))
                    .then(|| entry.session_ids.clone())
            })
            .unwrap_or_default()
    }

    pub(crate) fn subresource_cursor_advances(&self) -> &[PendingSubresourceNetworkCursorAdvance] {
        &self.cursor_advances.subresource
    }

    pub(crate) fn websocket_cursor_advances(&self) -> &[PendingWebSocketNetworkCursorAdvance] {
        &self.cursor_advances.websocket
    }
}

impl PendingSubresourceNetworkCursorAdvance {
    pub(crate) fn session_id(&self) -> Option<&str> {
        self.session_id.as_deref()
    }

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

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

impl PendingWebSocketNetworkCursorAdvance {
    pub(crate) fn session_id(&self) -> Option<&str> {
        self.session_id.as_deref()
    }

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

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

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

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

impl PendingNetworkBacklogDeliveryEntry {
    fn new(item: PendingNetworkBacklogDeliveryItem, session_ids: Vec<Option<String>>) -> Self {
        Self { item, session_ids }
    }

    fn from_websocket_item(
        item: PendingNetworkBacklogDeliveryItem,
        activity: &PendingWebSocketNetworkActivity,
    ) -> Self {
        let session_ids = match &item {
            PendingNetworkBacklogDeliveryItem::Subresource(_) => Vec::new(),
            PendingNetworkBacklogDeliveryItem::WebSocket(
                TargetWebSocketDeliveryRecord::Handshake(output),
            ) => activity.session_ids_for_record_index(output.index()),
            PendingNetworkBacklogDeliveryItem::WebSocket(TargetWebSocketDeliveryRecord::Frame(
                output,
            )) => activity.session_ids_for_event_index(output.index()),
            PendingNetworkBacklogDeliveryItem::WebSocket(
                TargetWebSocketDeliveryRecord::Lifecycle(output),
            ) => activity.session_ids_for_event_index(output.index()),
        };
        Self { item, session_ids }
    }

    fn delivery_order_index(&self) -> usize {
        self.item.delivery_order_index()
    }

    fn is_subresource(&self) -> bool {
        self.item.is_subresource()
    }
}

impl PendingNetworkBacklogDeliveryItem {
    #[cfg(test)]
    pub(crate) fn as_subresource(&self) -> Option<&TargetSubresourceNetworkDeliveryOutput> {
        match self {
            Self::Subresource(output) => Some(output.as_ref()),
            Self::WebSocket(_) => None,
        }
    }

    #[cfg(test)]
    pub(crate) fn as_websocket(&self) -> Option<&TargetWebSocketDeliveryRecord> {
        match self {
            Self::Subresource(_) => None,
            Self::WebSocket(output) => Some(output),
        }
    }

    fn delivery_order_index(&self) -> usize {
        match self {
            Self::Subresource(output) => output.delivery_order_index(),
            Self::WebSocket(output) => output.delivery_order_index(),
        }
    }

    fn is_subresource(&self) -> bool {
        matches!(self, Self::Subresource { .. })
    }

    #[cfg(test)]
    fn subresource_record_index(&self) -> Option<usize> {
        self.as_subresource()
            .map(TargetSubresourceNetworkDeliveryOutput::index)
    }

    #[cfg(test)]
    fn websocket_record_index(&self) -> Option<usize> {
        self.as_websocket()
            .and_then(TargetWebSocketDeliveryRecord::record_index)
    }

    #[cfg(test)]
    fn websocket_event_index(&self) -> Option<usize> {
        self.as_websocket()
            .and_then(TargetWebSocketDeliveryRecord::event_index)
    }
}

impl PendingSubresourceNetworkActivity {
    pub(crate) fn from_sessions(
        sessions: Vec<PendingSubresourceNetworkActivitySession>,
    ) -> Option<Self> {
        (!sessions.is_empty()).then_some(Self { sessions })
    }

    pub(crate) fn min_start_index(&self) -> usize {
        self.sessions
            .iter()
            .map(PendingSubresourceNetworkActivitySession::start_index)
            .min()
            .unwrap_or(0)
    }

    pub(crate) fn session_ids_for_record_index(&self, record_index: usize) -> Vec<Option<String>> {
        self.sessions
            .iter()
            .filter(|session| session.start_index <= record_index)
            .map(|session| session.session_id.clone())
            .collect()
    }

    fn cursor_advances_to(
        &self,
        emitted_record_end: usize,
    ) -> Vec<PendingSubresourceNetworkCursorAdvance> {
        self.sessions
            .iter()
            .map(|session| PendingSubresourceNetworkCursorAdvance {
                session_id: session.session_id.clone(),
                start_index: session.start_index(),
                record_count: emitted_record_end.saturating_sub(session.start_index()),
            })
            .collect()
    }
}

impl PendingSubresourceNetworkActivitySession {
    pub(crate) fn new(session_id: Option<String>, start_index: usize) -> Self {
        Self {
            session_id,
            start_index,
        }
    }

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

impl PendingWebSocketNetworkActivity {
    pub(crate) fn from_sessions(
        sessions: Vec<PendingWebSocketNetworkActivitySession>,
    ) -> Option<Self> {
        (!sessions.is_empty()).then_some(Self { sessions })
    }

    pub(crate) fn min_record_start_index(&self) -> usize {
        self.sessions
            .iter()
            .map(PendingWebSocketNetworkActivitySession::record_start_index)
            .min()
            .unwrap_or(0)
    }

    pub(crate) fn min_event_start_index(&self) -> usize {
        self.sessions
            .iter()
            .map(PendingWebSocketNetworkActivitySession::event_start_index)
            .min()
            .unwrap_or(0)
    }

    pub(crate) fn session_ids_for_record_index(&self, record_index: usize) -> Vec<Option<String>> {
        self.sessions
            .iter()
            .filter(|session| session.record_start_index <= record_index)
            .map(|session| session.session_id.clone())
            .collect()
    }

    pub(crate) fn session_ids_for_event_index(&self, event_index: usize) -> Vec<Option<String>> {
        self.sessions
            .iter()
            .filter(|session| session.event_start_index <= event_index)
            .map(|session| session.session_id.clone())
            .collect()
    }

    fn cursor_advances_to(
        &self,
        emitted_record_end: usize,
        emitted_event_end: usize,
    ) -> Vec<PendingWebSocketNetworkCursorAdvance> {
        self.sessions
            .iter()
            .map(|session| PendingWebSocketNetworkCursorAdvance {
                session_id: session.session_id.clone(),
                record_start_index: session.record_start_index(),
                record_count: emitted_record_end.saturating_sub(session.record_start_index()),
                event_start_index: session.event_start_index(),
                event_count: emitted_event_end.saturating_sub(session.event_start_index()),
            })
            .collect()
    }
}

impl PendingWebSocketNetworkActivitySession {
    pub(crate) fn new(
        session_id: Option<String>,
        record_start_index: usize,
        event_start_index: usize,
    ) -> Self {
        Self {
            session_id,
            record_start_index,
            event_start_index,
        }
    }

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

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

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TargetSubresourcePlanOutput {
    Complete(Box<TargetSubresourceMetadataOutput>),
    RequestStarted(Arc<TargetSubresourceRequestStartedOutput>),
    RequestExtraInfo(TargetSubresourceRequestExtraInfoOutput),
    ResponseStarted(Arc<TargetSubresourceResponseStartedOutput>),
    DataReceived(TargetSubresourceDataReceivedOutput),
    EventSourceMessageReceived(Box<TargetSubresourceEventSourceMessageReceivedOutput>),
    BodyFinished(Box<TargetSubresourceBodyFinishedOutput>),
}

impl TargetSubresourcePlanOutput {
    pub(crate) fn index(&self) -> usize {
        match self {
            Self::Complete(output) => output.index(),
            Self::RequestStarted(output) => output.index(),
            Self::RequestExtraInfo(output) => output.index(),
            Self::ResponseStarted(output) => output.index(),
            Self::DataReceived(output) => output.index(),
            Self::EventSourceMessageReceived(output) => output.index(),
            Self::BodyFinished(output) => output.index(),
        }
    }

    pub(crate) fn websocket_socket_id(&self) -> Option<u64> {
        match self {
            Self::Complete(output) => output.websocket_socket_id(),
            Self::RequestStarted(_)
            | Self::RequestExtraInfo(_)
            | Self::ResponseStarted(_)
            | Self::DataReceived(_)
            | Self::EventSourceMessageReceived(_)
            | Self::BodyFinished(_) => None,
        }
    }

    pub(crate) fn request_handle(&self) -> Option<SubresourceNetworkRequestHandle> {
        match self {
            Self::Complete(output) => output.request_handle(),
            Self::RequestStarted(output) => Some(output.handle()),
            Self::RequestExtraInfo(output) => Some(output.handle()),
            Self::ResponseStarted(output) => Some(output.handle()),
            Self::DataReceived(output) => Some(output.handle()),
            Self::EventSourceMessageReceived(output) => Some(output.handle()),
            Self::BodyFinished(output) => Some(output.handle()),
        }
    }

    fn into_delivery_output(self, request_id: String) -> TargetSubresourceNetworkDeliveryOutput {
        match self {
            Self::Complete(output) => TargetSubresourceNetworkDeliveryOutput::Complete(Box::new(
                TargetSubresourceCompleteNetworkDeliveryOutput::new(*output, request_id),
            )),
            Self::RequestStarted(output) => TargetSubresourceNetworkDeliveryOutput::RequestStarted(
                TargetSubresourceRequestNetworkDeliveryOutput::new(output, request_id),
            ),
            Self::RequestExtraInfo(output) => {
                TargetSubresourceNetworkDeliveryOutput::RequestExtraInfo(
                    TargetSubresourceRequestExtraInfoNetworkDeliveryOutput::new(output, request_id),
                )
            }
            Self::ResponseStarted(output) => {
                TargetSubresourceNetworkDeliveryOutput::ResponseStarted(
                    TargetSubresourceResponseNetworkDeliveryOutput::new(output, request_id),
                )
            }
            Self::DataReceived(output) => TargetSubresourceNetworkDeliveryOutput::DataReceived(
                TargetSubresourceDataNetworkDeliveryOutput::new(output, request_id),
            ),
            Self::EventSourceMessageReceived(output) => {
                TargetSubresourceNetworkDeliveryOutput::EventSourceMessageReceived(Box::new(
                    TargetSubresourceEventSourceMessageNetworkDeliveryOutput::new(
                        *output, request_id,
                    ),
                ))
            }
            Self::BodyFinished(output) => {
                TargetSubresourceNetworkDeliveryOutput::BodyFinished(Box::new(
                    TargetSubresourceBodyNetworkDeliveryOutput::new(*output, request_id),
                ))
            }
        }
    }

    #[cfg(test)]
    fn as_complete(&self) -> Option<&TargetSubresourceMetadataOutput> {
        match self {
            Self::Complete(output) => Some(output),
            Self::RequestStarted(_)
            | Self::RequestExtraInfo(_)
            | Self::ResponseStarted(_)
            | Self::DataReceived(_)
            | Self::EventSourceMessageReceived(_)
            | Self::BodyFinished(_) => None,
        }
    }

    #[cfg(test)]
    fn as_complete_mut(&mut self) -> Option<&mut TargetSubresourceMetadataOutput> {
        match self {
            Self::Complete(output) => Some(output),
            Self::RequestStarted(_)
            | Self::RequestExtraInfo(_)
            | Self::ResponseStarted(_)
            | Self::DataReceived(_)
            | Self::EventSourceMessageReceived(_)
            | Self::BodyFinished(_) => None,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceRequestStartedOutput {
    delivery_order_index: usize,
    index: usize,
    loader_id: String,
    handle: SubresourceNetworkRequestHandle,
    frame_id: Option<String>,
    document_url: Url,
    url: Url,
    method: String,
    request_headers: Vec<(String, String)>,
    request_body: Option<String>,
    request_body_bytes: Option<bytes::Bytes>,
    resource_type: SubresourceResourceType,
    request_initiator_type: SubresourceRequestInitiatorType,
    request_cookie_report: Option<StoredCookieQueryReport>,
}

impl TargetSubresourceRequestStartedOutput {
    fn from_page_request_started(
        delivery_order_index: usize,
        index: usize,
        loader_id: &str,
        request: &SubresourceRequestStarted,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            loader_id: loader_id.to_owned(),
            handle: request.handle(),
            frame_id: request.frame_id().map(str::to_owned),
            document_url: request.document_url().clone(),
            url: request.url().clone(),
            method: request.method().to_owned(),
            request_headers: request.request_headers().to_byte_strings(),
            request_body: request.request_body().map(str::to_owned),
            request_body_bytes: request.request_body_bytes().cloned(),
            resource_type: request.resource_type(),
            request_initiator_type: request.request_initiator_type(),
            request_cookie_report: request.request_cookie_report().cloned(),
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.handle
    }

    pub(crate) fn loader_id(&self) -> &str {
        &self.loader_id
    }

    pub(crate) fn frame_id(&self) -> Option<&str> {
        self.frame_id.as_deref()
    }

    pub(crate) fn document_url(&self) -> &Url {
        &self.document_url
    }

    pub(crate) fn url(&self) -> &Url {
        &self.url
    }

    pub(crate) fn method(&self) -> &str {
        &self.method
    }

    pub(crate) fn request_headers(&self) -> &[(String, String)] {
        &self.request_headers
    }

    pub(crate) fn request_body(&self) -> Option<&str> {
        self.request_body.as_deref()
    }

    pub(crate) fn request_body_bytes(&self) -> Option<&bytes::Bytes> {
        self.request_body_bytes.as_ref()
    }

    pub(crate) fn resource_type(&self) -> SubresourceResourceType {
        self.resource_type
    }

    pub(crate) fn request_initiator_type(&self) -> SubresourceRequestInitiatorType {
        self.request_initiator_type
    }

    pub(crate) fn request_cookie_report(&self) -> Option<&StoredCookieQueryReport> {
        self.request_cookie_report.as_ref()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceRequestExtraInfoOutput {
    delivery_order_index: usize,
    index: usize,
    request: Arc<TargetSubresourceRequestStartedOutput>,
    request_headers: Vec<(String, String)>,
    request_cookie_report: StoredCookieQueryReport,
}

impl TargetSubresourceRequestExtraInfoOutput {
    fn new(
        delivery_order_index: usize,
        index: usize,
        request: Arc<TargetSubresourceRequestStartedOutput>,
        request_headers: Vec<(String, String)>,
        request_cookie_report: StoredCookieQueryReport,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            request,
            request_headers,
            request_cookie_report,
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.request.handle()
    }

    pub(crate) fn request_cookie_report(&self) -> &StoredCookieQueryReport {
        &self.request_cookie_report
    }

    pub(crate) fn request_headers(&self) -> &[(String, String)] {
        &self.request_headers
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceResponseStartedOutput {
    delivery_order_index: usize,
    index: usize,
    request: Arc<TargetSubresourceRequestStartedOutput>,
    redirect_chain: Vec<TargetSubresourceRedirectOutput>,
    final_url: Url,
    status: u16,
    status_text: Option<String>,
    response_headers: Vec<(String, Vec<u8>)>,
    cookie_set_reports: Vec<StoredCookieSetReport>,
    from_cache: bool,
    network_request_headers: Option<Vec<(String, String)>>,
    negotiated_http_version: Option<NegotiatedHttpVersion>,
}

impl TargetSubresourceResponseStartedOutput {
    fn from_page_response_started(
        delivery_order_index: usize,
        index: usize,
        request: Arc<TargetSubresourceRequestStartedOutput>,
        response: &SubresourceResponseStarted,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            request,
            redirect_chain: response
                .redirect_chain()
                .iter()
                .map(TargetSubresourceRedirectOutput::from_page_redirect)
                .collect(),
            final_url: response.final_url().clone(),
            status: response.status(),
            status_text: response.status_text().map(str::to_owned),
            response_headers: response.response_headers().to_vec(),
            cookie_set_reports: response.cookie_set_reports().to_vec(),
            from_cache: response.from_cache(),
            network_request_headers: response
                .network_request_headers()
                .map(|headers| headers.to_vec()),
            negotiated_http_version: response.negotiated_http_version(),
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.request.handle()
    }

    pub(crate) fn request(&self) -> &TargetSubresourceRequestStartedOutput {
        &self.request
    }

    pub(crate) fn redirect_chain(&self) -> &[TargetSubresourceRedirectOutput] {
        &self.redirect_chain
    }

    pub(crate) fn final_url(&self) -> &Url {
        &self.final_url
    }

    pub(crate) fn status(&self) -> u16 {
        self.status
    }

    pub(crate) fn status_text(&self) -> Option<&str> {
        self.status_text.as_deref()
    }

    pub(crate) fn response_headers(&self) -> &[(String, Vec<u8>)] {
        &self.response_headers
    }

    pub(crate) fn cookie_set_reports(&self) -> &[StoredCookieSetReport] {
        &self.cookie_set_reports
    }

    pub(crate) fn is_from_cache(&self) -> bool {
        self.from_cache
    }

    pub(crate) fn network_request_headers(&self) -> Option<&[(String, String)]> {
        self.network_request_headers.as_deref()
    }

    pub(crate) fn negotiated_http_version(&self) -> Option<NegotiatedHttpVersion> {
        self.negotiated_http_version
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceDataReceivedOutput {
    delivery_order_index: usize,
    index: usize,
    data: SubresourceDataReceived,
}

impl TargetSubresourceDataReceivedOutput {
    fn from_page_data_received(
        delivery_order_index: usize,
        index: usize,
        data: &SubresourceDataReceived,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            data: data.clone(),
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.data.handle()
    }

    pub(crate) fn data_length(&self) -> usize {
        self.data.data_length()
    }

    pub(crate) fn encoded_data_length(&self) -> usize {
        self.data.encoded_data_length()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceEventSourceMessageReceivedOutput {
    delivery_order_index: usize,
    index: usize,
    message: SubresourceEventSourceMessageReceived,
}

impl TargetSubresourceEventSourceMessageReceivedOutput {
    fn from_page_event_source_message_received(
        delivery_order_index: usize,
        index: usize,
        message: &SubresourceEventSourceMessageReceived,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            message: message.clone(),
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.message.handle()
    }

    pub(crate) fn event_name(&self) -> &str {
        self.message.event_name()
    }

    pub(crate) fn event_id(&self) -> &str {
        self.message.event_id()
    }

    pub(crate) fn data(&self) -> &str {
        self.message.data()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceBodyFinishedOutput {
    delivery_order_index: usize,
    index: usize,
    request: Arc<TargetSubresourceRequestStartedOutput>,
    response: Option<Arc<TargetSubresourceResponseStartedOutput>>,
    result: SubresourceBodyFinishedResult,
    data_was_streamed: bool,
}

impl TargetSubresourceBodyFinishedOutput {
    fn from_page_body_finished(
        delivery_order_index: usize,
        index: usize,
        request: Arc<TargetSubresourceRequestStartedOutput>,
        response: Option<Arc<TargetSubresourceResponseStartedOutput>>,
        body: &SubresourceBodyFinished,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            request,
            response,
            result: body.result().clone(),
            data_was_streamed: body.data_was_streamed(),
        }
    }

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

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

    pub(crate) fn handle(&self) -> SubresourceNetworkRequestHandle {
        self.request.handle()
    }

    pub(crate) fn request(&self) -> &TargetSubresourceRequestStartedOutput {
        &self.request
    }

    pub(crate) fn result(&self) -> &SubresourceBodyFinishedResult {
        &self.result
    }

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

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceMetadataOutput {
    delivery_order_index: usize,
    index: usize,
    loader_id: String,
    response_body: Option<SubresourceResponseBody>,
    request_handle: Option<SubresourceNetworkRequestHandle>,
    websocket_socket_id: Option<u64>,
    frame_id: Option<String>,
    document_url: Url,
    url: Url,
    method: String,
    request_headers: Vec<(String, String)>,
    request_body: Option<String>,
    request_body_bytes: Option<bytes::Bytes>,
    resource_type: SubresourceResourceType,
    request_initiator_type: SubresourceRequestInitiatorType,
    request_cookie_report: Option<StoredCookieQueryReport>,
    outcome: TargetSubresourceMetadataOutcome,
    cookie_set_reports: Vec<StoredCookieSetReport>,
    from_cache: bool,
    network_request_headers: Option<Vec<(String, String)>>,
    negotiated_http_version: Option<NegotiatedHttpVersion>,
}

impl TargetSubresourceMetadataOutput {
    fn from_page_record(
        delivery_order_index: usize,
        index: usize,
        loader_id: &str,
        record: &SubresourceNetworkRecord,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            loader_id: loader_id.to_owned(),
            response_body: subresource_response_body(record),
            request_handle: record.request_handle(),
            websocket_socket_id: record.websocket_socket_id(),
            frame_id: record.frame_id().map(str::to_owned),
            document_url: record.document_url().clone(),
            url: record.url().clone(),
            method: record.method().to_owned(),
            request_headers: record.request_headers().to_byte_strings(),
            request_body: record.request_body().map(str::to_owned),
            request_body_bytes: record.request_body_bytes().cloned(),
            resource_type: record.resource_type(),
            request_initiator_type: record.request_initiator_type(),
            request_cookie_report: record.request_cookie_report().cloned(),
            outcome: TargetSubresourceMetadataOutcome::from_page_outcome(record.outcome()),
            cookie_set_reports: record.cookie_set_reports().to_vec(),
            from_cache: record.from_cache(),
            network_request_headers: record
                .network_request_headers()
                .map(|headers| headers.to_vec()),
            negotiated_http_version: record.negotiated_http_version(),
        }
    }

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

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

    pub(crate) fn loader_id(&self) -> &str {
        &self.loader_id
    }

    pub(crate) fn response_body(&self) -> Option<&SubresourceResponseBody> {
        self.response_body.as_ref()
    }

    pub(crate) fn request_handle(&self) -> Option<SubresourceNetworkRequestHandle> {
        self.request_handle
    }

    pub(crate) fn websocket_socket_id(&self) -> Option<u64> {
        self.websocket_socket_id
    }

    pub(crate) fn frame_id(&self) -> Option<&str> {
        self.frame_id.as_deref()
    }

    pub(crate) fn document_url(&self) -> &Url {
        &self.document_url
    }

    pub(crate) fn url(&self) -> &Url {
        &self.url
    }

    pub(crate) fn method(&self) -> &str {
        &self.method
    }

    pub(crate) fn request_headers(&self) -> &[(String, String)] {
        &self.request_headers
    }

    pub(crate) fn request_body(&self) -> Option<&str> {
        self.request_body.as_deref()
    }

    pub(crate) fn request_body_bytes(&self) -> Option<&bytes::Bytes> {
        self.request_body_bytes.as_ref()
    }

    pub(crate) fn resource_type(&self) -> SubresourceResourceType {
        self.resource_type
    }

    pub(crate) fn request_initiator_type(&self) -> SubresourceRequestInitiatorType {
        self.request_initiator_type
    }

    pub(crate) fn request_cookie_report(&self) -> Option<&StoredCookieQueryReport> {
        self.request_cookie_report.as_ref()
    }

    pub(crate) fn outcome(&self) -> &TargetSubresourceMetadataOutcome {
        &self.outcome
    }

    pub(crate) fn cookie_set_reports(&self) -> &[StoredCookieSetReport] {
        &self.cookie_set_reports
    }

    pub(crate) fn is_from_cache(&self) -> bool {
        self.from_cache
    }

    pub(crate) fn network_request_headers(&self) -> Option<&[(String, String)]> {
        self.network_request_headers.as_deref()
    }

    pub(crate) fn negotiated_http_version(&self) -> Option<NegotiatedHttpVersion> {
        self.negotiated_http_version
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TargetSubresourceNetworkDeliveryOutput {
    Complete(Box<TargetSubresourceCompleteNetworkDeliveryOutput>),
    RequestStarted(TargetSubresourceRequestNetworkDeliveryOutput),
    RequestExtraInfo(TargetSubresourceRequestExtraInfoNetworkDeliveryOutput),
    ResponseStarted(TargetSubresourceResponseNetworkDeliveryOutput),
    DataReceived(TargetSubresourceDataNetworkDeliveryOutput),
    EventSourceMessageReceived(Box<TargetSubresourceEventSourceMessageNetworkDeliveryOutput>),
    BodyFinished(Box<TargetSubresourceBodyNetworkDeliveryOutput>),
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceCompleteNetworkDeliveryOutput {
    request_id: String,
    output: TargetSubresourceMetadataOutput,
}

impl TargetSubresourceCompleteNetworkDeliveryOutput {
    fn new(output: TargetSubresourceMetadataOutput, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn metadata(&self) -> &TargetSubresourceMetadataOutput {
        &self.output
    }

    #[cfg(test)]
    pub(crate) fn index(&self) -> usize {
        self.output.index()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceRequestNetworkDeliveryOutput {
    request_id: String,
    output: Arc<TargetSubresourceRequestStartedOutput>,
}

impl TargetSubresourceRequestNetworkDeliveryOutput {
    fn new(output: Arc<TargetSubresourceRequestStartedOutput>, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceRequestStartedOutput {
        &self.output
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceRequestExtraInfoNetworkDeliveryOutput {
    request_id: String,
    output: TargetSubresourceRequestExtraInfoOutput,
}

impl TargetSubresourceRequestExtraInfoNetworkDeliveryOutput {
    fn new(output: TargetSubresourceRequestExtraInfoOutput, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceRequestExtraInfoOutput {
        &self.output
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceResponseNetworkDeliveryOutput {
    request_id: String,
    output: Arc<TargetSubresourceResponseStartedOutput>,
}

impl TargetSubresourceResponseNetworkDeliveryOutput {
    fn new(output: Arc<TargetSubresourceResponseStartedOutput>, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceResponseStartedOutput {
        &self.output
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceDataNetworkDeliveryOutput {
    request_id: String,
    output: TargetSubresourceDataReceivedOutput,
}

impl TargetSubresourceDataNetworkDeliveryOutput {
    fn new(output: TargetSubresourceDataReceivedOutput, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceDataReceivedOutput {
        &self.output
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceEventSourceMessageNetworkDeliveryOutput {
    request_id: String,
    output: TargetSubresourceEventSourceMessageReceivedOutput,
}

impl TargetSubresourceEventSourceMessageNetworkDeliveryOutput {
    fn new(output: TargetSubresourceEventSourceMessageReceivedOutput, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceEventSourceMessageReceivedOutput {
        &self.output
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceBodyNetworkDeliveryOutput {
    request_id: String,
    output: TargetSubresourceBodyFinishedOutput,
}

impl TargetSubresourceBodyNetworkDeliveryOutput {
    fn new(output: TargetSubresourceBodyFinishedOutput, request_id: String) -> Self {
        Self { request_id, output }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        self.output.delivery_order_index()
    }

    pub(crate) fn output(&self) -> &TargetSubresourceBodyFinishedOutput {
        &self.output
    }
}

impl TargetSubresourceNetworkDeliveryOutput {
    #[cfg(test)]
    pub(crate) fn request_id(&self) -> &str {
        match self {
            Self::Complete(output) => output.request_id(),
            Self::RequestStarted(output) => output.request_id(),
            Self::RequestExtraInfo(output) => output.request_id(),
            Self::ResponseStarted(output) => output.request_id(),
            Self::DataReceived(output) => output.request_id(),
            Self::EventSourceMessageReceived(output) => output.request_id(),
            Self::BodyFinished(output) => output.request_id(),
        }
    }

    pub(crate) fn delivery_order_index(&self) -> usize {
        match self {
            Self::Complete(output) => output.delivery_order_index(),
            Self::RequestStarted(output) => output.delivery_order_index(),
            Self::RequestExtraInfo(output) => output.delivery_order_index(),
            Self::ResponseStarted(output) => output.delivery_order_index(),
            Self::DataReceived(output) => output.delivery_order_index(),
            Self::EventSourceMessageReceived(output) => output.delivery_order_index(),
            Self::BodyFinished(output) => output.delivery_order_index(),
        }
    }

    #[cfg(test)]
    pub(crate) fn metadata(&self) -> &TargetSubresourceMetadataOutput {
        match self {
            Self::Complete(output) => output.metadata(),
            Self::RequestStarted(_)
            | Self::RequestExtraInfo(_)
            | Self::ResponseStarted(_)
            | Self::DataReceived(_)
            | Self::EventSourceMessageReceived(_)
            | Self::BodyFinished(_) => {
                panic!("staged subresource delivery output has no complete metadata")
            }
        }
    }

    #[cfg(test)]
    pub(crate) fn index(&self) -> usize {
        match self {
            Self::Complete(output) => output.index(),
            Self::RequestStarted(output) => output.output().index(),
            Self::RequestExtraInfo(output) => output.output().index(),
            Self::ResponseStarted(output) => output.output().index(),
            Self::DataReceived(output) => output.output().index(),
            Self::EventSourceMessageReceived(output) => output.output().index(),
            Self::BodyFinished(output) => output.output().index(),
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TargetSubresourceMetadataOutcome {
    Success {
        redirect_chain: Vec<TargetSubresourceRedirectOutput>,
        final_url: Url,
        status: u16,
        status_text: Option<String>,
        response_headers: Vec<(String, Vec<u8>)>,
        response_body_len: usize,
    },
    Failure {
        error_text: String,
    },
}

impl TargetSubresourceMetadataOutcome {
    fn from_page_outcome(outcome: &SubresourceNetworkOutcome) -> Self {
        match outcome {
            SubresourceNetworkOutcome::Success {
                redirect_chain,
                final_url,
                status,
                status_text,
                response_headers,
                response_body,
            } => Self::Success {
                redirect_chain: redirect_chain
                    .iter()
                    .map(TargetSubresourceRedirectOutput::from_page_redirect)
                    .collect(),
                final_url: final_url.clone(),
                status: *status,
                status_text: status_text.clone(),
                response_headers: response_headers.clone(),
                response_body_len: response_body.len(),
            },
            SubresourceNetworkOutcome::Failure { error_text } => Self::Failure {
                error_text: error_text.clone(),
            },
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetSubresourceRedirectOutput {
    pub(crate) from_url: Url,
    pub(crate) to_url: Url,
    pub(crate) status: u16,
    pub(crate) headers: Vec<(String, Vec<u8>)>,
    pub(crate) request_cookie_report: Option<StoredCookieQueryReport>,
    pub(crate) cookie_set_reports: Vec<StoredCookieSetReport>,
    pub(crate) from_cache: bool,
    pub(crate) negotiated_http_version: Option<NegotiatedHttpVersion>,
}

impl TargetSubresourceRedirectOutput {
    fn from_page_redirect(redirect: &NavigationRedirect) -> Self {
        Self {
            from_url: redirect.from_url.clone(),
            to_url: redirect.to_url.clone(),
            status: redirect.status,
            headers: redirect.headers.clone(),
            request_cookie_report: redirect.request_cookie_report.clone(),
            cookie_set_reports: redirect.cookie_set_reports.clone(),
            from_cache: redirect.from_cache,
            negotiated_http_version: redirect.negotiated_http_version,
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TargetWebSocketDeliveryRecord {
    Handshake(TargetWebSocketHandshakeDeliveryOutput),
    Frame(TargetWebSocketFrameDeliveryOutput),
    Lifecycle(TargetWebSocketLifecycleDeliveryOutput),
}

#[derive(Clone, Debug, Eq, PartialEq)]
enum TargetWebSocketDeliveryPlanRecord {
    Handshake(TargetWebSocketHandshakePlanOutput),
    Frame(TargetWebSocketFrameOutput),
    Lifecycle(TargetWebSocketLifecycleOutput),
}

impl TargetWebSocketDeliveryRecord {
    pub(crate) fn delivery_order_index(&self) -> usize {
        match self {
            Self::Handshake(output) => output.delivery_order_index(),
            Self::Frame(output) => output.delivery_order_index(),
            Self::Lifecycle(output) => output.delivery_order_index(),
        }
    }

    #[cfg(test)]
    pub(crate) fn record_index(&self) -> Option<usize> {
        match self {
            Self::Handshake(output) => Some(output.index()),
            Self::Frame(_) | Self::Lifecycle(_) => None,
        }
    }

    #[cfg(test)]
    pub(crate) fn event_index(&self) -> Option<usize> {
        match self {
            Self::Handshake(_) => None,
            Self::Frame(output) => Some(output.index()),
            Self::Lifecycle(output) => Some(output.index()),
        }
    }

    #[cfg(test)]
    pub(crate) fn as_handshake(&self) -> Option<&TargetWebSocketHandshakeDeliveryOutput> {
        match self {
            Self::Handshake(output) => Some(output),
            Self::Frame(_) | Self::Lifecycle(_) => None,
        }
    }

    #[cfg(test)]
    pub(crate) fn as_frame(&self) -> Option<&TargetWebSocketFrameDeliveryOutput> {
        match self {
            Self::Handshake(_) => None,
            Self::Frame(output) => Some(output),
            Self::Lifecycle(_) => None,
        }
    }

    #[cfg(test)]
    pub(crate) fn as_lifecycle(&self) -> Option<&TargetWebSocketLifecycleDeliveryOutput> {
        match self {
            Self::Handshake(_) | Self::Frame(_) => None,
            Self::Lifecycle(output) => Some(output),
        }
    }
}

impl TargetWebSocketDeliveryPlanRecord {
    fn socket_id(&self) -> u64 {
        match self {
            Self::Handshake(output) => output.socket_id,
            Self::Frame(output) => output.socket_id(),
            Self::Lifecycle(output) => output.socket_id(),
        }
    }

    fn into_delivery_record(self, request_id: String) -> TargetWebSocketDeliveryRecord {
        match self {
            Self::Handshake(output) => TargetWebSocketDeliveryRecord::Handshake(
                TargetWebSocketHandshakeDeliveryOutput::from_plan_output(output, request_id),
            ),
            Self::Frame(output) => TargetWebSocketDeliveryRecord::Frame(
                TargetWebSocketFrameDeliveryOutput::from_frame_output(output, request_id),
            ),
            Self::Lifecycle(output) => TargetWebSocketDeliveryRecord::Lifecycle(
                TargetWebSocketLifecycleDeliveryOutput::from_lifecycle_output(output, request_id),
            ),
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetWebSocketHandshakeDeliveryOutput {
    delivery_order_index: usize,
    request_id: String,
    index: usize,
    url: Url,
    request_headers: Vec<(String, String)>,
    response: Option<TargetWebSocketHandshakeResponseOutput>,
}

impl TargetWebSocketHandshakeDeliveryOutput {
    fn from_plan_output(record: TargetWebSocketHandshakePlanOutput, request_id: String) -> Self {
        let TargetWebSocketHandshakePlanOutput {
            delivery_order_index,
            socket_id: _,
            handshake:
                TargetWebSocketHandshakePlanPayload {
                    index,
                    url,
                    request_headers,
                    response,
                },
        } = record;
        Self {
            delivery_order_index,
            request_id,
            index,
            url,
            request_headers,
            response,
        }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

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

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

    pub(crate) fn url(&self) -> &Url {
        &self.url
    }

    pub(crate) fn request_headers(&self) -> &[(String, String)] {
        &self.request_headers
    }

    pub(crate) fn response(&self) -> Option<&TargetWebSocketHandshakeResponseOutput> {
        self.response.as_ref()
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetWebSocketHandshakeResponseOutput {
    status: u16,
    response_headers: Vec<(String, Vec<u8>)>,
}

impl TargetWebSocketHandshakeResponseOutput {
    pub(crate) fn status(&self) -> u16 {
        self.status
    }

    pub(crate) fn response_headers(&self) -> &[(String, Vec<u8>)] {
        &self.response_headers
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetWebSocketFrameOutput {
    delivery_order_index: usize,
    index: usize,
    timestamp_order_index: usize,
    socket_id: u64,
    direction: WebSocketFrameDirection,
    opcode: WebSocketFrameOpcode,
    payload_length: usize,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetWebSocketFrameDeliveryOutput {
    delivery_order_index: usize,
    request_id: String,
    index: usize,
    timestamp_order_index: usize,
    direction: WebSocketFrameDirection,
    opcode: WebSocketFrameOpcode,
    payload_length: usize,
}

#[derive(Clone, Debug, Eq, PartialEq)]
struct TargetWebSocketLifecycleOutput {
    delivery_order_index: usize,
    index: usize,
    timestamp_order_index: usize,
    socket_id: u64,
    kind: TargetWebSocketLifecycleDeliveryKind,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) struct TargetWebSocketLifecycleDeliveryOutput {
    delivery_order_index: usize,
    request_id: String,
    index: usize,
    timestamp_order_index: usize,
    kind: TargetWebSocketLifecycleDeliveryKind,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub(crate) enum TargetWebSocketLifecycleDeliveryKind {
    FrameError { error_text: String },
    Closed,
}

impl TargetWebSocketFrameOutput {
    fn from_page_event(
        delivery_order_index: usize,
        index: usize,
        event: &WebSocketNetworkEvent,
        subresource_record_count: usize,
    ) -> Self {
        Self {
            delivery_order_index,
            index,
            timestamp_order_index: websocket_event_timestamp_order_index(
                subresource_record_count,
                index,
            ),
            socket_id: event.socket_id(),
            direction: event.direction(),
            opcode: event.opcode(),
            payload_length: event.payload_length(),
        }
    }

    #[cfg(test)]
    pub(crate) fn index(&self) -> usize {
        self.index
    }

    fn socket_id(&self) -> u64 {
        self.socket_id
    }
}

impl TargetWebSocketFrameDeliveryOutput {
    fn from_frame_output(output: TargetWebSocketFrameOutput, request_id: String) -> Self {
        let TargetWebSocketFrameOutput {
            delivery_order_index,
            index,
            timestamp_order_index,
            socket_id: _,
            direction,
            opcode,
            payload_length,
        } = output;
        Self {
            delivery_order_index,
            request_id,
            index,
            timestamp_order_index,
            direction,
            opcode,
            payload_length,
        }
    }

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

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

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

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

    pub(crate) fn direction(&self) -> WebSocketFrameDirection {
        self.direction
    }

    pub(crate) fn opcode(&self) -> WebSocketFrameOpcode {
        self.opcode
    }

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

impl TargetWebSocketLifecycleOutput {
    fn from_page_event(
        delivery_order_index: usize,
        index: usize,
        event: &WebSocketLifecycleEvent,
        subresource_record_count: usize,
    ) -> Option<Self> {
        let kind = match event.kind() {
            WebSocketLifecycleKind::Error => TargetWebSocketLifecycleDeliveryKind::FrameError {
                error_text: event.error_text()?.to_owned(),
            },
            WebSocketLifecycleKind::Close => TargetWebSocketLifecycleDeliveryKind::Closed,
            WebSocketLifecycleKind::Open | WebSocketLifecycleKind::Closing => return None,
        };
        Some(Self {
            delivery_order_index,
            index,
            timestamp_order_index: websocket_event_timestamp_order_index(
                subresource_record_count,
                index,
            ),
            socket_id: event.socket_id(),
            kind,
        })
    }

    fn socket_id(&self) -> u64 {
        self.socket_id
    }
}

impl TargetWebSocketLifecycleDeliveryOutput {
    fn from_lifecycle_output(output: TargetWebSocketLifecycleOutput, request_id: String) -> Self {
        let TargetWebSocketLifecycleOutput {
            delivery_order_index,
            index,
            timestamp_order_index,
            socket_id: _,
            kind,
        } = output;
        Self {
            delivery_order_index,
            request_id,
            index,
            timestamp_order_index,
            kind,
        }
    }

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

    pub(crate) fn request_id(&self) -> &str {
        &self.request_id
    }

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

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

    pub(crate) fn kind(&self) -> &TargetWebSocketLifecycleDeliveryKind {
        &self.kind
    }
}

impl TargetNetworkOutputQueue {
    pub(crate) fn subresource_record_count(&self) -> usize {
        self.subresource_record_count
    }

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

    pub(crate) fn reset(&mut self) {
        let queue_generation = self.queue_generation.wrapping_add(1);
        *self = Self {
            queue_generation,
            ..Self::default()
        };
    }

    pub(crate) fn discard_observed_delivery_outputs(
        &mut self,
        subresource_record_cursor: usize,
        websocket_record_cursor: usize,
        websocket_event_cursor: usize,
    ) {
        self.delivery_outputs.discard_observed_outputs(
            subresource_record_cursor,
            websocket_record_cursor,
            websocket_event_cursor,
        );
    }

    #[cfg(test)]
    pub(crate) fn retained_delivery_output_count(&self) -> usize {
        self.delivery_outputs.outputs.len()
    }

    #[cfg(test)]
    fn items(&self) -> Vec<TargetSubresourceMetadataOutput> {
        self.delivery_outputs.subresource_outputs_from(0)
    }

    #[cfg(test)]
    fn websocket_frame_outputs_from(&self, start_index: usize) -> Vec<TargetWebSocketFrameOutput> {
        self.delivery_outputs
            .websocket_frame_outputs_from(start_index)
    }

    fn next_delivery_order_index(&mut self) -> usize {
        let index = self.next_delivery_order_index;
        self.next_delivery_order_index = self.next_delivery_order_index.wrapping_add(1);
        index
    }

    pub(crate) fn pending_network_backlog_delivery_snapshot_from_backlog(
        &self,
        backlog: &mut TargetNetworkBacklogPreparedDelivery,
    ) -> Option<PendingNetworkBacklogDeliverySnapshot> {
        let token = backlog.take_delivery_token()?;
        if !token.matches_generation(self.queue_generation) {
            return None;
        }
        let (entries, cursor_advances) = token.into_parts();
        PendingNetworkBacklogDeliverySnapshot::from_delivery_entries(entries, cursor_advances)
    }

    #[cfg(test)]
    pub(crate) fn backlog_prepared_delivery(
        &self,
        cursor: TargetNetworkBacklogActivityCursor,
    ) -> TargetNetworkBacklogPreparedDelivery {
        let subresource_activity = cursor.subresource_record_start_index.map(|start_index| {
            PendingSubresourceNetworkActivity::from_sessions(vec![
                PendingSubresourceNetworkActivitySession::new(None, start_index),
            ])
            .expect("test cursor activity should contain one session")
        });
        let websocket_activity = match (
            cursor.websocket_record_start_index,
            cursor.websocket_event_start_index,
        ) {
            (Some(record_start_index), event_start_index) => {
                PendingWebSocketNetworkActivity::from_sessions(vec![
                    PendingWebSocketNetworkActivitySession::new(
                        None,
                        record_start_index,
                        event_start_index.unwrap_or(usize::MAX),
                    ),
                ])
            }
            (None, Some(event_start_index)) => {
                PendingWebSocketNetworkActivity::from_sessions(vec![
                    PendingWebSocketNetworkActivitySession::new(
                        None,
                        usize::MAX,
                        event_start_index,
                    ),
                ])
            }
            _ => None,
        };
        let mut request_ids = TargetNetworkBacklogTestRequestIds;
        self.backlog_prepared_delivery_for_activity(
            subresource_activity,
            websocket_activity,
            &mut request_ids,
        )
    }

    pub(crate) fn backlog_prepared_delivery_for_activity(
        &self,
        subresource_activity: Option<PendingSubresourceNetworkActivity>,
        websocket_activity: Option<PendingWebSocketNetworkActivity>,
        request_ids: &mut impl TargetNetworkBacklogRequestIdResolver,
    ) -> TargetNetworkBacklogPreparedDelivery {
        let mut outputs = TargetNetworkBacklogPreparedDelivery::default();
        let batch = self.delivery_outputs.prepared_delivery_batch_for_activity(
            subresource_activity,
            websocket_activity,
            self.subresource_record_count,
            self.websocket_event_count,
            request_ids,
        );
        outputs.push_batch(self.queue_generation, batch);
        outputs
    }

    /// Appends one source-bound fact from the concrete renderer output stream.
    ///
    /// The cumulative Network report retained by `Page` is diagnostic state,
    /// not a live protocol source. Every item accepted here is therefore an
    /// incremental FIFO fact; replacement Documents are separated by the
    /// caller's exact lifecycle identity check and queue reset.
    pub(crate) fn append_renderer_output_item_for_loader(
        &mut self,
        item: &ScriptNetworkOutputItem,
        document_loader_id: &str,
    ) {
        let mut subresource_index = self.subresource_record_count;
        self.append_page_output_item_for_loader(item, document_loader_id, &mut subresource_index);
    }

    fn append_page_output_item_for_loader(
        &mut self,
        item: &ScriptNetworkOutputItem,
        document_loader_id: &str,
        subresource_index: &mut usize,
    ) {
        match item {
            ScriptNetworkOutputItem::SubresourceNetworkRecord(record) => {
                self.append_subresource_record(*subresource_index, document_loader_id, record);
                *subresource_index += 1;
            }
            ScriptNetworkOutputItem::SubresourceRequestStarted(request) => {
                self.append_subresource_request_started(
                    *subresource_index,
                    document_loader_id,
                    request,
                );
                *subresource_index += 1;
            }
            ScriptNetworkOutputItem::SubresourceResponseStarted(response) => {
                self.append_missing_subresource_request_extra_info(
                    *subresource_index,
                    response.handle(),
                    response.network_request_headers(),
                    None,
                );
                if self.append_subresource_response_started(*subresource_index, response) {
                    *subresource_index += 1;
                }
            }
            ScriptNetworkOutputItem::SubresourceDataReceived(data) => {
                self.append_subresource_data_received(*subresource_index, data);
                *subresource_index += 1;
            }
            ScriptNetworkOutputItem::SubresourceEventSourceMessageReceived(message) => {
                self.append_subresource_event_source_message_received(*subresource_index, message);
                *subresource_index += 1;
            }
            ScriptNetworkOutputItem::SubresourceBodyFinished(body) => {
                if self.append_subresource_body_finished(*subresource_index, body) {
                    *subresource_index += 1;
                }
            }
            ScriptNetworkOutputItem::WebSocketNetworkEvent(event) => {
                let subresource_record_count = self.subresource_record_count;
                let delivery_order_index = self.next_delivery_order_index();
                let websocket_event_index = self.websocket_event_count;
                self.delivery_outputs.push_frame_from_page_event(
                    delivery_order_index,
                    websocket_event_index,
                    event,
                    subresource_record_count,
                );
                self.websocket_event_count += 1;
            }
            ScriptNetworkOutputItem::WebSocketLifecycleEvent(event) => {
                self.append_websocket_lifecycle_event(event);
            }
        }
    }

    fn append_subresource_record(
        &mut self,
        index: usize,
        document_loader_id: &str,
        record: &SubresourceNetworkRecord,
    ) {
        if let Some(handle) = record.request_handle() {
            if !self.completed_subresource_handles.insert(handle) {
                self.subresource_record_count = index + 1;
                return;
            }
            if self.staged_subresource_requests.contains_key(&handle) {
                self.append_staged_subresource_record_completion(index, handle, record);
                self.subresource_record_count = index + 1;
                return;
            }
        }
        let delivery_order_index = self.next_delivery_order_index();
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::Complete(Box::new(
                TargetSubresourceMetadataOutput::from_page_record(
                    delivery_order_index,
                    index,
                    document_loader_id,
                    record,
                ),
            )));
        let appended_websocket_handshake = self
            .delivery_outputs
            .push_handshake_output_if_websocket(delivery_order_index, index, record);
        self.subresource_record_count = index + 1;
        if appended_websocket_handshake && let Some(socket_id) = record.websocket_socket_id() {
            self.websocket_handshake_recorded_socket_ids
                .insert(socket_id);
            self.flush_pending_websocket_lifecycle_events(socket_id);
        }
    }

    fn append_websocket_lifecycle_event(&mut self, event: &WebSocketLifecycleEvent) {
        if !matches!(
            event.kind(),
            WebSocketLifecycleKind::Error | WebSocketLifecycleKind::Close
        ) {
            return;
        }
        if !self
            .websocket_handshake_recorded_socket_ids
            .contains(&event.socket_id())
        {
            // Failed handshakes reach the renderer as Error then metadata, while CDP requires
            // webSocketCreated/webSocketWillSendHandshakeRequest before terminal events.
            self.pending_websocket_lifecycle_events
                .entry(event.socket_id())
                .or_default()
                .push(event.clone());
            return;
        }
        self.push_websocket_lifecycle_event(event);
    }

    fn flush_pending_websocket_lifecycle_events(&mut self, socket_id: u64) {
        let Some(events) = self.pending_websocket_lifecycle_events.remove(&socket_id) else {
            return;
        };
        for event in events {
            self.push_websocket_lifecycle_event(&event);
        }
    }

    fn push_websocket_lifecycle_event(&mut self, event: &WebSocketLifecycleEvent) {
        let delivery_order_index = self.next_delivery_order_index();
        let websocket_event_index = self.websocket_event_count;
        if self.delivery_outputs.push_lifecycle_from_page_event(
            delivery_order_index,
            websocket_event_index,
            event,
            self.subresource_record_count,
        ) {
            self.websocket_event_count += 1;
        }
    }

    fn append_staged_subresource_record_completion(
        &mut self,
        index: usize,
        handle: SubresourceNetworkRequestHandle,
        record: &SubresourceNetworkRecord,
    ) {
        self.append_missing_subresource_request_extra_info(
            index,
            handle,
            record.network_request_headers(),
            record.request_cookie_report(),
        );
        match record.outcome() {
            SubresourceNetworkOutcome::Success {
                redirect_chain,
                final_url,
                status,
                status_text,
                response_headers,
                response_body,
            } => {
                let response = SubresourceResponseStarted::new(
                    handle,
                    redirect_chain.clone(),
                    final_url.clone(),
                    *status,
                    response_headers.clone(),
                    record.cookie_set_reports().to_vec(),
                )
                .with_status_text(status_text.clone())
                .with_from_cache(record.from_cache())
                .with_network_request_headers(
                    record
                        .network_request_headers()
                        .map(|headers| headers.to_vec()),
                )
                .with_negotiated_http_version(record.negotiated_http_version());
                self.append_subresource_response_started(index, &response);
                let body = SubresourceBodyFinished::ready(handle, response_body.clone());
                self.append_subresource_body_finished(index, &body);
            }
            SubresourceNetworkOutcome::Failure { error_text } => {
                let body = SubresourceBodyFinished::failed(handle, error_text.clone());
                self.append_subresource_body_finished(index, &body);
            }
        }
    }

    fn append_subresource_request_started(
        &mut self,
        index: usize,
        document_loader_id: &str,
        request: &SubresourceRequestStarted,
    ) {
        let delivery_order_index = self.next_delivery_order_index();
        let output = Arc::new(
            TargetSubresourceRequestStartedOutput::from_page_request_started(
                delivery_order_index,
                index,
                document_loader_id,
                request,
            ),
        );
        self.staged_subresource_requests
            .insert(output.handle(), output.clone());
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::RequestStarted(output));
        self.subresource_record_count = index + 1;
    }

    fn append_subresource_response_started(
        &mut self,
        index: usize,
        response: &SubresourceResponseStarted,
    ) -> bool {
        let Some(request) = self
            .staged_subresource_requests
            .get(&response.handle())
            .cloned()
        else {
            return false;
        };
        let delivery_order_index = self.next_delivery_order_index();
        let output = Arc::new(
            TargetSubresourceResponseStartedOutput::from_page_response_started(
                delivery_order_index,
                index,
                request,
                response,
            ),
        );
        self.staged_subresource_responses
            .insert(output.handle(), output.clone());
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::ResponseStarted(output));
        self.subresource_record_count = index + 1;
        true
    }

    fn append_subresource_request_extra_info(
        &mut self,
        index: usize,
        handle: SubresourceNetworkRequestHandle,
        request_headers: Vec<(String, String)>,
        request_cookie_report: StoredCookieQueryReport,
    ) -> bool {
        let Some(request) = self.staged_subresource_requests.get(&handle).cloned() else {
            return false;
        };
        let delivery_order_index = self.next_delivery_order_index();
        let output = TargetSubresourceRequestExtraInfoOutput::new(
            delivery_order_index,
            index,
            request,
            request_headers,
            request_cookie_report,
        );
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::RequestExtraInfo(output));
        self.subresource_record_count = index + 1;
        true
    }

    fn append_missing_subresource_request_extra_info(
        &mut self,
        index: usize,
        handle: SubresourceNetworkRequestHandle,
        network_request_headers: Option<&[(String, String)]>,
        request_cookie_report: Option<&StoredCookieQueryReport>,
    ) {
        let Some(request) = self.staged_subresource_requests.get(&handle) else {
            return;
        };
        if request.request_cookie_report().is_some() {
            return;
        }
        let request_headers = network_request_headers
            .unwrap_or_else(|| request.request_headers())
            .to_vec();
        let Some(request_cookie_report) = request_cookie_report.cloned().or_else(|| {
            network_request_headers
                .is_some()
                .then(StoredCookieQueryReport::default)
        }) else {
            return;
        };
        self.append_subresource_request_extra_info(
            index,
            handle,
            request_headers,
            request_cookie_report,
        );
    }

    fn append_subresource_data_received(&mut self, index: usize, data: &SubresourceDataReceived) {
        let delivery_order_index = self.next_delivery_order_index();
        let output = TargetSubresourceDataReceivedOutput::from_page_data_received(
            delivery_order_index,
            index,
            data,
        );
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::DataReceived(output));
        self.subresource_record_count = index + 1;
    }

    fn append_subresource_event_source_message_received(
        &mut self,
        index: usize,
        message: &SubresourceEventSourceMessageReceived,
    ) {
        let delivery_order_index = self.next_delivery_order_index();
        let output =
            TargetSubresourceEventSourceMessageReceivedOutput::from_page_event_source_message_received(
                delivery_order_index,
                index,
                message,
            );
        self.delivery_outputs.push_subresource(
            TargetSubresourcePlanOutput::EventSourceMessageReceived(Box::new(output)),
        );
        self.subresource_record_count = index + 1;
    }

    fn append_subresource_body_finished(
        &mut self,
        index: usize,
        body: &SubresourceBodyFinished,
    ) -> bool {
        let Some(request) = self
            .staged_subresource_requests
            .get(&body.handle())
            .cloned()
        else {
            return false;
        };
        let response = self
            .staged_subresource_responses
            .get(&body.handle())
            .cloned();
        let delivery_order_index = self.next_delivery_order_index();
        let output = TargetSubresourceBodyFinishedOutput::from_page_body_finished(
            delivery_order_index,
            index,
            request,
            response,
            body,
        );
        self.delivery_outputs
            .push_subresource(TargetSubresourcePlanOutput::BodyFinished(Box::new(output)));
        self.subresource_record_count = index + 1;
        true
    }
}

fn websocket_event_timestamp_order_index(
    subresource_record_count: usize,
    websocket_event_index: usize,
) -> usize {
    subresource_record_count
        .wrapping_add(websocket_event_index)
        .wrapping_add(1)
}

fn is_index_visible_between(index: usize, start_index: usize, end_index: usize) -> bool {
    start_index <= index && index < end_index
}

fn subresource_response_body(record: &SubresourceNetworkRecord) -> Option<SubresourceResponseBody> {
    let SubresourceNetworkOutcome::Success { response_body, .. } = record.outcome() else {
        return None;
    };
    Some(response_body.clone())
}

#[cfg(test)]
mod tests {
    use std::cell::Cell;
    use std::cell::RefCell;
    use std::collections::HashMap;
    use std::sync::Arc;

    use moli_cookie_jar::StoredCookieQueryReport;
    use moli_core::page::{
        NavigationRedirect, ScriptNetworkOutputItem, SubresourceBodyFinished,
        SubresourceNetworkRecord, SubresourceNetworkRequestHandle, SubresourceRequestInitiatorType,
        SubresourceRequestStarted, SubresourceResourceType, SubresourceResponseBody,
        SubresourceResponseStarted, WebSocketFrameDirection, WebSocketFrameOpcode,
        WebSocketLifecycleEvent, WebSocketNetworkEvent,
    };
    use url::Url;

    use super::{
        PendingNetworkBacklogDeliveryItem, PendingNetworkBacklogDeliverySnapshot,
        PendingSubresourceNetworkActivity, PendingSubresourceNetworkActivitySession,
        PendingWebSocketNetworkActivity, PendingWebSocketNetworkActivitySession,
        TargetNetworkBacklogActivityCursor, TargetNetworkBacklogRequestIdResolver,
        TargetNetworkDeliveryOutput, TargetNetworkDeliveryOutputItem, TargetNetworkOutputQueue,
        TargetSubresourceMetadataOutcome, TargetSubresourceMetadataOutput,
        TargetSubresourceNetworkDeliveryOutput, TargetSubresourcePlanOutput,
        TargetWebSocketDeliveryOutputSource, TargetWebSocketDeliveryPlanRecord,
        TargetWebSocketDeliveryRecord, TargetWebSocketFrameOutput,
        TargetWebSocketLifecycleDeliveryKind,
    };

    struct TestBacklogRequestIds;

    impl TargetNetworkBacklogRequestIdResolver for TestBacklogRequestIds {
        fn request_id_for_subresource_output(
            &mut self,
            output: &TargetSubresourcePlanOutput,
        ) -> String {
            output
                .websocket_socket_id()
                .map(|socket_id| format!("REQ-{socket_id}"))
                .unwrap_or_else(|| format!("REQ-{}", output.index() + 1))
        }

        fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
            format!("REQ-{socket_id}")
        }
    }

    #[derive(Default)]
    struct StableSubresourceHandleRequestIds {
        request_ids_by_handle: HashMap<u64, String>,
        next_request_id: usize,
    }

    impl TargetNetworkBacklogRequestIdResolver for StableSubresourceHandleRequestIds {
        fn request_id_for_subresource_output(
            &mut self,
            output: &TargetSubresourcePlanOutput,
        ) -> String {
            if let Some(handle) = output.request_handle() {
                return self
                    .request_ids_by_handle
                    .entry(handle.get())
                    .or_insert_with(|| {
                        self.next_request_id += 1;
                        format!("REQ-H{}", handle.get())
                    })
                    .clone();
            }
            self.next_request_id += 1;
            format!("REQ-{}", self.next_request_id)
        }

        fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
            format!("REQ-{socket_id}")
        }
    }

    fn pending_delivery_snapshot(
        output_queue: &TargetNetworkOutputQueue,
        subresource_activity: Option<PendingSubresourceNetworkActivity>,
        websocket_activity: Option<PendingWebSocketNetworkActivity>,
        request_ids: &mut impl TargetNetworkBacklogRequestIdResolver,
    ) -> Option<PendingNetworkBacklogDeliverySnapshot> {
        let mut backlog = output_queue.backlog_prepared_delivery_for_activity(
            subresource_activity,
            websocket_activity,
            request_ids,
        );
        output_queue.pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
    }

    fn subresource_outputs(
        snapshot: &PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<&TargetSubresourceNetworkDeliveryOutput> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| item.as_subresource())
            .collect()
    }

    fn websocket_outputs(
        snapshot: &PendingNetworkBacklogDeliverySnapshot,
    ) -> Vec<&TargetWebSocketDeliveryRecord> {
        snapshot
            .outputs()
            .into_iter()
            .filter_map(|item| item.as_websocket())
            .collect()
    }

    fn producer_network_items_for_test(
        subresource_records: &[SubresourceNetworkRecord],
        websocket_events: &[WebSocketNetworkEvent],
    ) -> Vec<ScriptNetworkOutputItem> {
        subresource_records
            .iter()
            .cloned()
            .map(Box::new)
            .map(ScriptNetworkOutputItem::SubresourceNetworkRecord)
            .chain(
                websocket_events
                    .iter()
                    .cloned()
                    .map(ScriptNetworkOutputItem::WebSocketNetworkEvent),
            )
            .collect()
    }

    fn apply_network_items_for_test(
        output_queue: &mut TargetNetworkOutputQueue,
        subresource_records: &[SubresourceNetworkRecord],
        websocket_events: &[WebSocketNetworkEvent],
    ) {
        append_concrete_items_for_test(
            output_queue,
            &producer_network_items_for_test(subresource_records, websocket_events),
            "LOADER-1",
        );
    }

    fn append_concrete_items_for_test(
        output_queue: &mut TargetNetworkOutputQueue,
        items: &[ScriptNetworkOutputItem],
        document_loader_id: &str,
    ) {
        for item in items {
            output_queue.append_renderer_output_item_for_loader(item, document_loader_id);
        }
    }

    fn subresource_record(
        resource_type: SubresourceResourceType,
        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,
            resource_type,
            None,
            Vec::new(),
            url,
            200,
            Vec::new(),
            String::new(),
            Vec::new(),
        )
    }

    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 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 failed_websocket_record(
        url: &str,
        socket_id: u64,
        error_text: &str,
    ) -> SubresourceNetworkRecord {
        SubresourceNetworkRecord::failure(
            None,
            Url::parse("https://example.com/").expect("document URL should parse"),
            Url::parse(url).expect("test URL should parse"),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::WebSocket,
            error_text.to_owned(),
        )
        .with_websocket_socket_id(socket_id)
    }

    fn subresource_record_with_body(url: &str, body: &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::Fetch,
            None,
            Vec::new(),
            url,
            200,
            Vec::new(),
            body.to_owned(),
            Vec::new(),
        )
    }

    fn failed_subresource_record(url: &str) -> SubresourceNetworkRecord {
        SubresourceNetworkRecord::failure(
            None,
            Url::parse("https://example.com/").expect("document URL should parse"),
            Url::parse(url).expect("test URL should parse"),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::Fetch,
            "net::ERR_FAILED".to_owned(),
        )
    }

    #[test]
    fn target_network_output_queue_overflow_counters_do_not_panic() {
        let mut queue = TargetNetworkOutputQueue {
            queue_generation: u64::MAX,
            next_delivery_order_index: usize::MAX,
            ..Default::default()
        };

        queue.reset();
        assert_eq!(queue.queue_generation, 0);

        queue.next_delivery_order_index = usize::MAX;
        assert_eq!(queue.next_delivery_order_index(), usize::MAX);
        assert_eq!(queue.next_delivery_order_index, 0);

        assert_eq!(
            super::websocket_event_timestamp_order_index(usize::MAX, 0),
            0
        );
    }

    #[test]
    fn complete_subresource_outputs_skip_duplicate_request_handle() {
        let handle = SubresourceNetworkRequestHandle::new(7);
        let record = subresource_record(SubresourceResourceType::Fetch, "https://example.com/api")
            .with_request_handle(handle);
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record.clone())),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)),
        ];
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");
        assert_eq!(output_queue.subresource_record_count(), 2);

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("deduplicated output should still produce a snapshot");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 1);
        assert_eq!(outputs[0].request_id(), "REQ-H7");
        assert_eq!(snapshot.subresource_cursor_advances()[0].record_count(), 1);
    }

    #[test]
    fn staged_subresource_outputs_deliver_ordered_events_with_stable_request_id() {
        let handle = SubresourceNetworkRequestHandle::new(7);
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let request_url =
            Url::parse("https://example.com/image.png").expect("request URL should parse");
        let request = SubresourceRequestStarted::new(
            handle,
            Some("FRAME-1".to_owned()),
            document_url,
            request_url.clone(),
            "GET".to_owned(),
            vec![("accept".to_owned(), "image/png".to_owned())].into(),
            None,
            SubresourceResourceType::Image,
            SubresourceRequestInitiatorType::Parser,
            None,
        );
        let response = SubresourceResponseStarted::new(
            handle,
            Vec::new(),
            request_url,
            200,
            vec![("content-type".to_owned(), b"image/png".to_vec())],
            Vec::new(),
        )
        .with_from_cache(true);
        let body = SubresourceBodyFinished::ready(
            handle,
            SubresourceResponseBody::from_bytes(vec![1, 2, 3]),
        );
        let items = vec![
            ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(request)),
            ScriptNetworkOutputItem::SubresourceResponseStarted(Box::new(response)),
            ScriptNetworkOutputItem::SubresourceBodyFinished(Box::new(body)),
        ];
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");
        assert_eq!(output_queue.subresource_record_count(), 3);

        let staged_request = output_queue
            .staged_subresource_requests
            .get(&handle)
            .expect("request should remain staged");
        let staged_response = output_queue
            .staged_subresource_responses
            .get(&handle)
            .expect("response should remain staged");
        let request_output = match output_queue.delivery_outputs.outputs[0].output() {
            TargetNetworkDeliveryOutput::Subresource(output) => match output.as_ref() {
                TargetSubresourcePlanOutput::RequestStarted(output) => output,
                _ => panic!("first output should be request-started"),
            },
            TargetNetworkDeliveryOutput::WebSocket(_) => {
                panic!("first output should be a subresource")
            }
        };
        let response_output = match output_queue.delivery_outputs.outputs[1].output() {
            TargetNetworkDeliveryOutput::Subresource(output) => match output.as_ref() {
                TargetSubresourcePlanOutput::ResponseStarted(output) => output,
                _ => panic!("second output should be response-started"),
            },
            TargetNetworkDeliveryOutput::WebSocket(_) => {
                panic!("second output should be a subresource")
            }
        };
        let body_output = match output_queue.delivery_outputs.outputs[2].output() {
            TargetNetworkDeliveryOutput::Subresource(output) => match output.as_ref() {
                TargetSubresourcePlanOutput::BodyFinished(output) => output,
                _ => panic!("third output should be body-finished"),
            },
            TargetNetworkDeliveryOutput::WebSocket(_) => {
                panic!("third output should be a subresource")
            }
        };
        assert!(Arc::ptr_eq(staged_request, request_output));
        assert!(Arc::ptr_eq(staged_request, &response_output.request));
        assert!(Arc::ptr_eq(staged_request, &body_output.request));
        assert!(Arc::ptr_eq(staged_response, response_output));
        assert!(
            body_output
                .response
                .as_ref()
                .is_some_and(|response| Arc::ptr_eq(staged_response, response))
        );

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("staged output should produce a backlog snapshot");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 3);
        assert!(matches!(
            outputs[0],
            TargetSubresourceNetworkDeliveryOutput::RequestStarted(_)
        ));
        assert!(matches!(
            outputs[1],
            TargetSubresourceNetworkDeliveryOutput::ResponseStarted(_)
        ));
        let TargetSubresourceNetworkDeliveryOutput::ResponseStarted(response) = &outputs[1] else {
            unreachable!("checked response-started variant above");
        };
        assert!(response.output().is_from_cache());
        assert!(matches!(
            outputs[2],
            TargetSubresourceNetworkDeliveryOutput::BodyFinished(_)
        ));
        assert_eq!(
            outputs
                .iter()
                .map(|output| output.request_id())
                .collect::<Vec<_>>(),
            vec!["REQ-H7", "REQ-H7", "REQ-H7"]
        );
        assert_eq!(snapshot.subresource_cursor_advances()[0].record_count(), 3);

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 1),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("cursor should be able to resume from staged response");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 2);
        assert!(matches!(
            outputs[0],
            TargetSubresourceNetworkDeliveryOutput::ResponseStarted(_)
        ));
        assert!(matches!(
            outputs[1],
            TargetSubresourceNetworkDeliveryOutput::BodyFinished(_)
        ));
    }

    #[test]
    fn staged_request_followed_by_complete_record_delivers_response_and_body_only() {
        let handle = SubresourceNetworkRequestHandle::new(7);
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let request_url = Url::parse("https://example.com/api").expect("request URL should parse");
        let request = SubresourceRequestStarted::new(
            handle,
            Some("FRAME-1".to_owned()),
            document_url,
            request_url.clone(),
            "PATCH".to_owned(),
            vec![("x-test".to_owned(), "yes".to_owned())].into(),
            Some("payload".to_owned()),
            SubresourceResourceType::Fetch,
            SubresourceRequestInitiatorType::Script,
            None,
        );
        let record = subresource_record(SubresourceResourceType::Fetch, request_url.as_str())
            .with_request_handle(handle);
        let items = vec![
            ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(request)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record.clone())),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)),
        ];
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");
        assert_eq!(output_queue.subresource_record_count(), 3);

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("bridged staged output should produce a backlog snapshot");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 3);
        assert!(matches!(
            outputs[0],
            TargetSubresourceNetworkDeliveryOutput::RequestStarted(_)
        ));
        assert!(matches!(
            outputs[1],
            TargetSubresourceNetworkDeliveryOutput::ResponseStarted(_)
        ));
        assert!(matches!(
            outputs[2],
            TargetSubresourceNetworkDeliveryOutput::BodyFinished(_)
        ));
        assert_eq!(
            outputs
                .iter()
                .map(|output| output.request_id())
                .collect::<Vec<_>>(),
            vec!["REQ-H7", "REQ-H7", "REQ-H7"]
        );
        assert_eq!(snapshot.subresource_cursor_advances()[0].record_count(), 2);
    }

    #[test]
    fn concrete_renderer_items_append_without_cumulative_snapshot_recovery() {
        let handle = SubresourceNetworkRequestHandle::new(17);
        let document_url =
            Url::parse("https://example.com/page").expect("document URL should parse");
        let request_url =
            Url::parse("https://example.com/incremental").expect("request URL should parse");
        let request = ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(
            SubresourceRequestStarted::new(
                handle,
                Some("FRAME-1".to_owned()),
                document_url,
                request_url.clone(),
                "GET".to_owned(),
                Vec::new().into(),
                None,
                SubresourceResourceType::Xhr,
                SubresourceRequestInitiatorType::Script,
                None,
            ),
        ));
        let completion = ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
            subresource_record(SubresourceResourceType::Xhr, request_url.as_str())
                .with_request_handle(handle),
        ));
        let mut output_queue = TargetNetworkOutputQueue::default();

        output_queue.append_renderer_output_item_for_loader(&request, "LOADER-concrete");
        output_queue.append_renderer_output_item_for_loader(&completion, "LOADER-concrete");

        assert_eq!(output_queue.subresource_record_count(), 2);
        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("incremental renderer records should retain their staged request");
        let outputs = subresource_outputs(&snapshot);
        assert!(matches!(
            outputs.as_slice(),
            [
                TargetSubresourceNetworkDeliveryOutput::RequestStarted(_),
                TargetSubresourceNetworkDeliveryOutput::ResponseStarted(_),
                TargetSubresourceNetworkDeliveryOutput::BodyFinished(_)
            ]
        ));
        assert!(
            outputs
                .iter()
                .all(|output| output.request_id() == "REQ-H17")
        );
    }

    #[test]
    fn staged_compact_network_completion_emits_one_transport_extra_info() {
        let handle = SubresourceNetworkRequestHandle::new(8);
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let request_url = Url::parse("https://example.com/api").expect("request URL should parse");
        let request = SubresourceRequestStarted::new(
            handle,
            Some("FRAME-1".to_owned()),
            document_url,
            request_url.clone(),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::Fetch,
            SubresourceRequestInitiatorType::Script,
            None,
        );
        let record = subresource_record(SubresourceResourceType::Fetch, request_url.as_str())
            .with_request_handle(handle)
            .with_network_request_headers(Some(vec![(
                "User-Agent".to_owned(),
                "Moli/Test".to_owned(),
            )]));
        let items = vec![
            ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(request)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)),
        ];
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("network completion should produce a backlog snapshot");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 4);
        let extras = outputs
            .iter()
            .filter_map(|output| match output {
                TargetSubresourceNetworkDeliveryOutput::RequestExtraInfo(output) => Some(output),
                _ => None,
            })
            .collect::<Vec<_>>();
        assert_eq!(extras.len(), 1);
        assert_eq!(
            extras[0].output().request_headers(),
            &[("User-Agent".to_owned(), "Moli/Test".to_owned())]
        );
        assert!(matches!(
            outputs[2],
            TargetSubresourceNetworkDeliveryOutput::ResponseStarted(_)
        ));
    }

    #[test]
    fn staged_request_followed_by_redirect_complete_record_preserves_redirect_chain() {
        let handle = SubresourceNetworkRequestHandle::new(7);
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let start_url =
            Url::parse("https://example.com/api-start").expect("start URL should parse");
        let final_url =
            Url::parse("https://other.example/api-final").expect("final URL should parse");
        let request = SubresourceRequestStarted::new(
            handle,
            Some("FRAME-1".to_owned()),
            document_url.clone(),
            start_url.clone(),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::Fetch,
            SubresourceRequestInitiatorType::Script,
            None,
        );
        let record = SubresourceNetworkRecord::success(
            Some("FRAME-1".to_owned()),
            document_url,
            start_url.clone(),
            "GET".to_owned(),
            Vec::new().into(),
            None,
            SubresourceResourceType::Fetch,
            Some(StoredCookieQueryReport::default()),
            vec![NavigationRedirect {
                source: moli_fetch::RedirectSource::Network,
                from_url: start_url.clone(),
                to_url: final_url.clone(),
                status: 307,
                headers: vec![(
                    "location".to_owned(),
                    final_url.as_str().as_bytes().to_vec(),
                )],
                network_extra_info_available: false,
                request_extra_info: None,
                response_extra_info: None,
                redirect_has_extra_info: false,
                request_cookie_report: None,
                cookie_set_reports: Vec::new(),
                from_cache: true,
                negotiated_http_version: None,
            }],
            final_url.clone(),
            200,
            Vec::new(),
            String::new(),
            Vec::new(),
        )
        .with_request_handle(handle)
        .with_from_cache(true);
        let items = vec![
            ScriptNetworkOutputItem::SubresourceRequestStarted(Box::new(request)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(record)),
        ];
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("redirect completion should produce staged output");
        let outputs = subresource_outputs(&snapshot);
        assert_eq!(outputs.len(), 4);
        assert!(matches!(
            outputs[0],
            TargetSubresourceNetworkDeliveryOutput::RequestStarted(_)
        ));
        assert!(matches!(
            outputs[1],
            TargetSubresourceNetworkDeliveryOutput::RequestExtraInfo(_)
        ));
        let TargetSubresourceNetworkDeliveryOutput::ResponseStarted(response) = outputs[2] else {
            panic!("redirect completion should deliver response-start output");
        };
        assert_eq!(response.request_id(), "REQ-H7");
        assert_eq!(response.output().redirect_chain().len(), 1);
        assert_eq!(response.output().redirect_chain()[0].from_url, start_url);
        assert_eq!(response.output().redirect_chain()[0].to_url, final_url);
        assert!(response.output().redirect_chain()[0].from_cache);
        assert!(
            response.output().is_from_cache(),
            "staged response synthesized from a compact completion record should preserve cache provenance"
        );
        assert!(matches!(
            outputs[3],
            TargetSubresourceNetworkDeliveryOutput::BodyFinished(_)
        ));
    }

    #[test]
    fn complete_subresource_record_delivery_preserves_cache_state() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let record = subresource_record(
            SubresourceResourceType::Script,
            "https://example.com/app.js",
        )
        .with_from_cache(true);
        append_concrete_items_for_test(
            &mut output_queue,
            &[ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
                record,
            ))],
            "LOADER-1",
        );

        let metadata = output_queue
            .items()
            .into_iter()
            .next()
            .expect("complete compact record should produce metadata output");
        assert!(
            metadata.is_from_cache(),
            "metadata output should retain the compact record cache provenance"
        );

        let activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ]);
        let mut request_ids = StableSubresourceHandleRequestIds::default();
        let snapshot = pending_delivery_snapshot(&output_queue, activity, None, &mut request_ids)
            .expect("complete compact record should produce a backlog snapshot");
        let outputs = subresource_outputs(&snapshot);
        let TargetSubresourceNetworkDeliveryOutput::Complete(output) = outputs[0] else {
            panic!("complete compact record should stay a complete delivery output");
        };
        assert!(
            output.metadata().is_from_cache(),
            "delivery output should keep cache provenance for CDP/BiDi responseStarted synthesis"
        );
    }

    fn expected_subresource_metadata(
        index: usize,
        resource_type: SubresourceResourceType,
        url: &str,
        request_headers: Vec<(String, String)>,
        status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
    ) -> TargetSubresourceMetadataOutput {
        expected_subresource_metadata_with_delivery_order(
            index,
            index,
            resource_type,
            url,
            request_headers,
            status,
            response_headers,
        )
    }

    fn expected_subresource_metadata_with_delivery_order(
        index: usize,
        delivery_order_index: usize,
        resource_type: SubresourceResourceType,
        url: &str,
        request_headers: Vec<(String, String)>,
        status: u16,
        response_headers: Vec<(String, Vec<u8>)>,
    ) -> TargetSubresourceMetadataOutput {
        let url = Url::parse(url).expect("test URL should parse");
        TargetSubresourceMetadataOutput {
            delivery_order_index,
            index,
            loader_id: "LOADER-1".to_owned(),
            response_body: Some(SubresourceResponseBody::from_bytes(Vec::new())),
            request_handle: None,
            websocket_socket_id: (resource_type == SubresourceResourceType::WebSocket).then_some(7),
            frame_id: None,
            document_url: Url::parse("https://example.com/").expect("document URL should parse"),
            url: url.clone(),
            method: "GET".to_owned(),
            request_headers,
            request_body: None,
            request_body_bytes: None,
            resource_type,
            request_initiator_type: SubresourceRequestInitiatorType::Script,
            request_cookie_report: None,
            outcome: TargetSubresourceMetadataOutcome::Success {
                redirect_chain: Vec::new(),
                final_url: url,
                status,
                status_text: None,
                response_headers,
                response_body_len: 0,
            },
            cookie_set_reports: Vec::new(),
            from_cache: false,
            network_request_headers: None,
            negotiated_http_version: None,
        }
    }

    #[test]
    fn target_network_output_queue_snapshot_items_preserve_producer_order() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let script_record = subresource_record(
            SubresourceResourceType::Script,
            "https://example.com/app.js",
        );
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let fetch_record =
            subresource_record(SubresourceResourceType::Fetch, "https://example.com/api");
        let websocket_event = websocket_event(7, 4);
        let all_items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(script_record)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record)),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(fetch_record)),
        ];

        append_concrete_items_for_test(&mut output_queue, &all_items, "LOADER-1");

        assert_eq!(output_queue.subresource_record_count, 3);
        assert_eq!(output_queue.websocket_event_count, 1);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![
                expected_subresource_metadata(
                    0,
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
                expected_subresource_metadata(
                    1,
                    SubresourceResourceType::WebSocket,
                    "wss://example.com/socket",
                    vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())],
                    101,
                    vec![("Upgrade".to_owned(), b"websocket".to_vec())],
                ),
                expected_subresource_metadata_with_delivery_order(
                    2,
                    3,
                    SubresourceResourceType::Fetch,
                    "https://example.com/api",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
            ],
            "producer item ingestion should keep subresource metadata items stable without mixing WebSocket frame delivery outputs"
        );
        assert_eq!(
            output_queue.websocket_frame_outputs_from(0),
            vec![TargetWebSocketFrameOutput {
                delivery_order_index: 2,
                index: 0,
                timestamp_order_index: 3,
                socket_id: 7,
                direction: WebSocketFrameDirection::Received,
                opcode: WebSocketFrameOpcode::Text,
                payload_length: 4,
            }],
            "WebSocket frame payload should be owned by the WebSocket delivery output queue"
        );
    }

    #[test]
    fn target_network_output_queue_preserves_concrete_producer_item_order() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let script_record = subresource_record(
            SubresourceResourceType::Script,
            "https://example.com/app.js",
        );
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let fetch_record =
            subresource_record(SubresourceResourceType::Fetch, "https://example.com/api");
        let websocket_event = websocket_event(7, 4);
        let events = [websocket_event];
        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)),
        ];

        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");

        assert_eq!(output_queue.subresource_record_count, 3);
        assert_eq!(output_queue.websocket_event_count, 1);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![
                expected_subresource_metadata(
                    0,
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
                expected_subresource_metadata(
                    1,
                    SubresourceResourceType::WebSocket,
                    "wss://example.com/socket",
                    vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())],
                    101,
                    vec![("Upgrade".to_owned(), b"websocket".to_vec())],
                ),
                expected_subresource_metadata_with_delivery_order(
                    2,
                    3,
                    SubresourceResourceType::Fetch,
                    "https://example.com/api",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
            ],
            "page output append update should preserve script producer order inside the queue"
        );
        assert_eq!(
            output_queue.websocket_frame_outputs_from(0),
            vec![TargetWebSocketFrameOutput {
                delivery_order_index: 2,
                index: 0,
                timestamp_order_index: 3,
                socket_id: 7,
                direction: WebSocketFrameDirection::Received,
                opcode: WebSocketFrameOpcode::Text,
                payload_length: 4,
            }]
        );
    }

    #[test]
    fn target_network_output_queue_processes_concrete_lifecycle_items_once() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let websocket_record = websocket_record("wss://example.com/socket", 7);
        let lifecycle = WebSocketLifecycleEvent::open(
            7,
            Url::parse("https://example.com/").expect("document URL should parse"),
            Url::parse("wss://example.com/socket").expect("websocket URL should parse"),
        );
        let websocket_event = websocket_event(7, 4);

        append_concrete_items_for_test(
            &mut output_queue,
            &[
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
                    websocket_record.clone(),
                )),
                ScriptNetworkOutputItem::WebSocketLifecycleEvent(lifecycle),
                ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event),
            ],
            "LOADER-1",
        );

        assert_eq!(output_queue.subresource_record_count, 1);
        assert_eq!(output_queue.websocket_event_count, 1);
        assert_eq!(
            output_queue.websocket_frame_outputs_from(0),
            vec![TargetWebSocketFrameOutput {
                delivery_order_index: 1,
                index: 0,
                timestamp_order_index: 2,
                socket_id: 7,
                direction: WebSocketFrameDirection::Received,
                opcode: WebSocketFrameOpcode::Text,
                payload_length: 4,
            }],
            "each concrete lifecycle item should be applied once without duplicating Network/WebSocket output"
        );
    }

    #[test]
    fn failed_websocket_lifecycle_waits_for_handshake_and_preserves_terminal_event_order() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let document_url = Url::parse("https://example.com/").expect("document URL should parse");
        let socket_url =
            Url::parse("wss://example.com/socket").expect("websocket URL should parse");
        let error = WebSocketLifecycleEvent::error(
            7,
            document_url.clone(),
            socket_url.clone(),
            "WebSocket handshake failed with HTTP status 404".to_owned(),
        );
        let close =
            WebSocketLifecycleEvent::close(7, document_url, socket_url, 1006, String::new(), false);

        append_concrete_items_for_test(
            &mut output_queue,
            &[ScriptNetworkOutputItem::WebSocketLifecycleEvent(error)],
            "LOADER-1",
        );
        assert_eq!(
            output_queue.websocket_event_count, 0,
            "an error observed before its handshake record must remain pending and unobservable"
        );
        assert_eq!(output_queue.delivery_outputs.websocket_records().count(), 0);

        append_concrete_items_for_test(
            &mut output_queue,
            &[
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(
                    failed_websocket_record(
                        "wss://example.com/socket",
                        7,
                        "WebSocket handshake failed with HTTP status 404",
                    ),
                )),
                ScriptNetworkOutputItem::WebSocketLifecycleEvent(close),
            ],
            "LOADER-1",
        );

        assert_eq!(output_queue.websocket_event_count, 2);
        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(None, Some(0), Some(0)),
        );
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("failed WebSocket lifecycle should create protocol backlog");
        let records = websocket_outputs(&snapshot);
        assert_eq!(records.len(), 3);
        let handshake = records[0]
            .as_handshake()
            .expect("handshake must precede terminal lifecycle events");
        assert!(
            handshake.response().is_none(),
            "failed handshake must not synthesize a handshake response event"
        );
        let handshake_request_id = handshake.request_id().to_owned();
        let frame_error = records[1].as_lifecycle().expect("error lifecycle delivery");
        assert_eq!(
            frame_error.kind(),
            &TargetWebSocketLifecycleDeliveryKind::FrameError {
                error_text: "WebSocket handshake failed with HTTP status 404".to_owned(),
            }
        );
        let closed = records[2].as_lifecycle().expect("close lifecycle delivery");
        assert_eq!(closed.kind(), &TargetWebSocketLifecycleDeliveryKind::Closed);
        for record in records {
            let request_id = match record {
                TargetWebSocketDeliveryRecord::Handshake(output) => output.request_id(),
                TargetWebSocketDeliveryRecord::Frame(output) => output.request_id(),
                TargetWebSocketDeliveryRecord::Lifecycle(output) => output.request_id(),
            };
            assert_eq!(
                request_id, handshake_request_id,
                "all events for one WebSocket must share a request id"
            );
        }
    }

    #[test]
    fn target_network_output_queue_tracks_incremental_websocket_records() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let mut records = vec![subresource_record(
            SubresourceResourceType::Script,
            "https://example.com/app.js",
        )];

        apply_network_items_for_test(&mut output_queue, &records, &[]);
        assert_eq!(output_queue.subresource_record_count, 1);
        assert_eq!(output_queue.websocket_event_count, 0);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![expected_subresource_metadata(
                0,
                SubresourceResourceType::Script,
                "https://example.com/app.js",
                Vec::new(),
                200,
                Vec::new(),
            )]
        );

        records.push(websocket_record("wss://example.com/socket", 7));
        apply_network_items_for_test(
            &mut output_queue,
            &records[1..],
            &[websocket_event(7, 4), websocket_event(7, 9)],
        );
        assert_eq!(output_queue.subresource_record_count, 2);
        assert_eq!(output_queue.websocket_event_count, 2);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![
                expected_subresource_metadata(
                    0,
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
                expected_subresource_metadata(
                    1,
                    SubresourceResourceType::WebSocket,
                    "wss://example.com/socket",
                    vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())],
                    101,
                    vec![("Upgrade".to_owned(), b"websocket".to_vec())],
                ),
            ]
        );
        assert_eq!(
            output_queue.websocket_frame_outputs_from(0),
            vec![
                TargetWebSocketFrameOutput {
                    delivery_order_index: 2,
                    index: 0,
                    timestamp_order_index: 3,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 4,
                },
                TargetWebSocketFrameOutput {
                    delivery_order_index: 3,
                    index: 1,
                    timestamp_order_index: 4,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 9,
                },
            ],
            "WebSocket frame payload should be retained in lifecycle state"
        );

        apply_network_items_for_test(&mut output_queue, &[], &[websocket_event(7, 16)]);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![
                expected_subresource_metadata(
                    0,
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                    Vec::new(),
                    200,
                    Vec::new(),
                ),
                expected_subresource_metadata(
                    1,
                    SubresourceResourceType::WebSocket,
                    "wss://example.com/socket",
                    vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())],
                    101,
                    vec![("Upgrade".to_owned(), b"websocket".to_vec())],
                ),
            ],
            "syncing only new websocket events should not rescan records or duplicate handshake state"
        );
        assert_eq!(
            output_queue.websocket_frame_outputs_from(0),
            vec![
                TargetWebSocketFrameOutput {
                    delivery_order_index: 2,
                    index: 0,
                    timestamp_order_index: 3,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 4,
                },
                TargetWebSocketFrameOutput {
                    delivery_order_index: 3,
                    index: 1,
                    timestamp_order_index: 4,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 9,
                },
                TargetWebSocketFrameOutput {
                    delivery_order_index: 4,
                    index: 2,
                    timestamp_order_index: 5,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 16,
                },
            ],
            "syncing only new websocket events should append lifecycle frame records"
        );

        let handshake_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 1, 3),
        ])
        .expect("session should create WebSocket activity");
        let mut request_ids = TestBacklogRequestIds;
        let handshake_snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(handshake_activity),
            &mut request_ids,
        )
        .expect("handshake delivery snapshot should contain pending output");
        let websocket_records = websocket_outputs(&handshake_snapshot);
        assert_eq!(websocket_records.len(), 1);
        let handshake = websocket_records[0]
            .as_handshake()
            .expect("WebSocket delivery output should be handshake");
        assert_eq!(handshake.request_id(), "REQ-7");
        assert_eq!(
            handshake.url().as_str(),
            "wss://example.com/socket",
            "handshake delivery outputs should carry stable payload without rereading page records"
        );

        assert_eq!(
            output_queue.websocket_frame_outputs_from(1),
            vec![
                TargetWebSocketFrameOutput {
                    delivery_order_index: 3,
                    index: 1,
                    timestamp_order_index: 4,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 9,
                },
                TargetWebSocketFrameOutput {
                    delivery_order_index: 4,
                    index: 2,
                    timestamp_order_index: 5,
                    socket_id: 7,
                    direction: WebSocketFrameDirection::Received,
                    opcode: WebSocketFrameOpcode::Text,
                    payload_length: 16,
                },
            ],
            "frame outputs should carry stable payload without rereading page events"
        );

        let replacement_records = vec![subresource_record(
            SubresourceResourceType::Fetch,
            "https://example.com/api",
        )];
        output_queue.reset();
        apply_network_items_for_test(&mut output_queue, &replacement_records, &[]);
        assert_eq!(output_queue.subresource_record_count, 1);
        assert_eq!(
            output_queue.items().to_vec(),
            vec![expected_subresource_metadata(
                0,
                SubresourceResourceType::Fetch,
                "https://example.com/api",
                Vec::new(),
                200,
                Vec::new(),
            )],
            "a replacement Document queue must not retain stale items"
        );
        assert_eq!(output_queue.websocket_event_count, 0);
    }

    #[test]
    fn target_network_output_queue_keeps_body_sources_inside_metadata_items() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = [
            failed_subresource_record("https://example.com/fail"),
            subresource_record_with_body("https://example.com/api", "api-body"),
        ];

        apply_network_items_for_test(&mut output_queue, &records, &[]);

        assert_eq!(output_queue.subresource_record_count, 2);
        let items = output_queue.items();
        assert!(matches!(
            &items[0],
            TargetSubresourceMetadataOutput {
                index: 0,
                response_body: None,
                outcome: TargetSubresourceMetadataOutcome::Failure { .. },
                ..
            }
        ));
        let success_output = &items[1];
        assert!(matches!(
            success_output,
            TargetSubresourceMetadataOutput {
                index: 1,
                response_body: Some(_),
                outcome: TargetSubresourceMetadataOutcome::Success {
                    response_body_len: 8,
                    ..
                },
                ..
            }
        ));
        assert_eq!(
            success_output
                .response_body()
                .expect("success response should retain a body source")
                .diagnostic_bytes()
                .as_ref(),
            b"api-body"
        );
    }

    #[test]
    fn target_network_output_queue_records_websocket_handshake_payload_in_delivery_outputs() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket", 7),
        ];

        apply_network_items_for_test(&mut output_queue, &records, &[]);

        let handshake_records = output_queue
            .delivery_outputs
            .websocket_records()
            .filter_map(|record| match record {
                TargetWebSocketDeliveryPlanRecord::Handshake(record) => Some(record),
                TargetWebSocketDeliveryPlanRecord::Frame(_)
                | TargetWebSocketDeliveryPlanRecord::Lifecycle(_) => None,
            })
            .collect::<Vec<_>>();
        assert_eq!(
            handshake_records.len(),
            1,
            "only WebSocket subresource records should enter delivery outputs"
        );
        let plan_output = handshake_records[0];
        assert_eq!(plan_output.socket_id, 7);
        assert_eq!(plan_output.handshake.index, 1);
        assert_eq!(
            plan_output.handshake.url.as_str(),
            "wss://example.com/socket"
        );
        assert_eq!(
            plan_output.handshake.request_headers,
            vec![("Sec-WebSocket-Version".to_owned(), "13".to_owned())]
        );
        let response = plan_output
            .handshake
            .response
            .as_ref()
            .expect("successful WebSocket handshake should carry response metadata");
        assert_eq!(response.status(), 101);
        assert_eq!(
            response.response_headers(),
            &[("Upgrade".to_owned(), b"websocket".to_vec())]
        );
    }

    #[test]
    fn target_network_output_queue_uses_single_websocket_delivery_output_log() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = vec![websocket_event(7, 4), websocket_event(7, 9)];

        apply_network_items_for_test(&mut output_queue, &records, &events);

        assert_eq!(
            output_queue.delivery_outputs.websocket_records().count(),
            3,
            "handshake and frame payloads should share one WebSocket delivery output log"
        );
        assert!(matches!(
            output_queue.delivery_outputs.websocket_record_mut(0).unwrap(),
            TargetWebSocketDeliveryPlanRecord::Handshake(record)
                if record.socket_id == 7 && record.handshake.index == 0
        ));
        assert!(matches!(
            output_queue.delivery_outputs.websocket_record_mut(1).unwrap(),
            TargetWebSocketDeliveryPlanRecord::Frame(output)
                if output.socket_id() == 7 && output.index() == 0 && output.payload_length == 4
        ));
        assert!(matches!(
            output_queue.delivery_outputs.websocket_record_mut(2).unwrap(),
            TargetWebSocketDeliveryPlanRecord::Frame(output)
                if output.socket_id() == 7 && output.index() == 1 && output.payload_length == 9
        ));
    }

    #[test]
    fn target_network_output_queue_maintains_append_time_network_source_items() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = [
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket-a", 7),
            subresource_record(SubresourceResourceType::Fetch, "https://example.com/api"),
            websocket_record("wss://example.com/socket-b", 8),
        ];
        let events = [websocket_event(7, 4), websocket_event(8, 9)];

        apply_network_items_for_test(&mut output_queue, &records[..2], &events[..1]);
        apply_network_items_for_test(&mut output_queue, &records[2..], &events[1..]);

        assert_eq!(
            output_queue
                .delivery_outputs
                .outputs
                .iter()
                .filter_map(TargetNetworkDeliveryOutputItem::subresource_output)
                .map(TargetSubresourceMetadataOutput::index)
                .collect::<Vec<_>>(),
            vec![0, 1, 2, 3],
            "combined delivery output items should track subresource source indexes in append order"
        );
        assert_eq!(
            output_queue
                .delivery_outputs
                .first_output_position_for_activity(Some(2), None, None),
            4,
            "subresource prepare should seek past the combined append-time prefix whose subresource cursor is clean"
        );
        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 2),
        ])
        .expect("test session should create subresource activity");
        let mut request_ids = TestBacklogRequestIds;
        let subresource_snapshot = pending_delivery_snapshot(
            &output_queue,
            Some(subresource_activity),
            None,
            &mut request_ids,
        )
        .expect("partial subresource source scan should include records after the cursor");
        assert_eq!(
            subresource_outputs(&subresource_snapshot)
                .iter()
                .map(|output| output.metadata().url().as_str())
                .collect::<Vec<_>>(),
            vec!["https://example.com/api", "wss://example.com/socket-b"],
            "combined source scan should filter subresource items by source cursor without a visible range token"
        );
        assert_eq!(
            output_queue
                .delivery_outputs
                .websocket_sources()
                .collect::<Vec<_>>(),
            vec![
                TargetWebSocketDeliveryOutputSource::Handshake { record_index: 1 },
                TargetWebSocketDeliveryOutputSource::Frame { event_index: 0 },
                TargetWebSocketDeliveryOutputSource::Handshake { record_index: 3 },
                TargetWebSocketDeliveryOutputSource::Frame { event_index: 1 },
            ],
            "WebSocket source index should track every output in append order"
        );
        assert_eq!(
            output_queue
                .delivery_outputs
                .outputs
                .iter()
                .map(|item| {
                    (
                        item.subresource_record_tail_after_item(),
                        item.websocket_record_tail_after_item(),
                        item.websocket_event_tail_after_item(),
                    )
                })
                .collect::<Vec<_>>(),
            vec![
                (1, 0, 0),
                (2, 0, 0),
                (2, 2, 0),
                (2, 2, 1),
                (3, 2, 1),
                (4, 2, 1),
                (4, 4, 1),
                (4, 4, 2),
            ],
            "combined output items should cache per-family source tails needed to seek dirty cursors"
        );
        assert_eq!(
            output_queue
                .delivery_outputs
                .first_output_position_for_activity(None, Some(3), Some(0)),
            3,
            "WebSocket prepare should seek past combined outputs whose record and event tails are both clean"
        );
        assert_eq!(
            output_queue
                .delivery_outputs
                .first_output_position_for_activity(None, Some(3), Some(1)),
            6,
            "combined WebSocket seek should honor both record and event cursor tails"
        );
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 3, 0),
        ])
        .expect("test session should create websocket activity");
        let mut request_ids = TestBacklogRequestIds;
        let partial_snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(websocket_activity),
            &mut request_ids,
        )
        .expect("partial WebSocket source scan should include late handshake and all frames");
        assert_eq!(
            partial_snapshot
                .outputs()
                .iter()
                .map(|item| match item {
                    PendingNetworkBacklogDeliveryItem::Subresource(_) => "subresource",
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Handshake(_),
                    ) => "handshake",
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Frame(_),
                    ) => "frame",
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Lifecycle(_),
                    ) => "lifecycle",
                })
                .collect::<Vec<_>>(),
            vec!["frame", "handshake", "frame"],
            "WebSocket source scan should filter by source cursor without regrouping append order"
        );

        output_queue.reset();
        assert!(output_queue.delivery_outputs.outputs.is_empty());
    }

    #[test]
    fn backlog_outputs_use_subresource_and_websocket_delivery_output_queues() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket", 7),
        ];
        let events = vec![websocket_event(7, 4)];

        apply_network_items_for_test(&mut output_queue, &records, &events);

        assert!(
            !output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::default())
                .has_output(),
            "backlog presence should stay empty when no Network listener cursor is visible"
        );
        assert!(
            output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    Some(0),
                    Some(0),
                    Some(0),
                ))
                .has_output(),
            "queue should project typed pending backlog items as one Network-owned output"
        );
        assert!(
            output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    None,
                    Some(0),
                    Some(0),
                ))
                .has_output(),
            "subresource and WebSocket backlog cursors should be independent"
        );
        assert!(
            output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    Some(records.len()),
                    Some(records.len()),
                    Some(0),
                ))
                .has_output(),
            "frame backlog should be independently visible after record cursors catch up"
        );
    }

    #[test]
    fn subresource_backlog_outputs_keep_loader_from_ingest_document() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let items = producer_network_items_for_test(
            &[subresource_record(
                SubresourceResourceType::Fetch,
                "https://example.com/api",
            )],
            &[],
        );

        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-DOC");

        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("subresource backlog should materialize");
        let outputs = subresource_outputs(&snapshot);
        let TargetSubresourceNetworkDeliveryOutput::Complete(output) = outputs[0] else {
            panic!("test record should produce a complete subresource output");
        };

        assert_eq!(output.metadata().loader_id(), "LOADER-DOC");
    }

    #[test]
    fn target_network_output_queue_builds_pending_delivery_snapshots() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket", 7),
        ];
        let events = vec![websocket_event(7, 4)];
        apply_network_items_for_test(&mut output_queue, &records, &events);

        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(Some("SID-1".to_owned()), 0),
        ])
        .expect("session should create subresource activity");
        let mut request_ids = TestBacklogRequestIds;
        let snapshot = pending_delivery_snapshot(
            &output_queue,
            Some(subresource_activity),
            None,
            &mut request_ids,
        )
        .expect("subresource snapshot should contain pending records");
        assert_eq!(
            snapshot.subresource_session_ids_for_record_index(0),
            vec![Some("SID-1".to_owned())],
            "combined snapshot should carry subresource fanout"
        );
        let subresource_records = subresource_outputs(&snapshot);
        assert_eq!(subresource_records.len(), 2);
        assert_eq!(subresource_records[0].request_id(), "REQ-1");
        assert_eq!(
            subresource_records[1].request_id(),
            "REQ-7",
            "WebSocket subresource delivery should prefer the request id already bound to its socket"
        );
        assert_eq!(
            subresource_records[1].metadata().websocket_socket_id(),
            Some(7)
        );
        assert_eq!(snapshot.subresource_cursor_advances()[0].record_count(), 2);

        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(Some("SID-1".to_owned()), 0, 0),
        ])
        .expect("session should create WebSocket activity");
        let mut request_ids = TestBacklogRequestIds;
        let snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(websocket_activity),
            &mut request_ids,
        )
        .expect("websocket delivery snapshot should contain pending output");
        assert_eq!(
            snapshot.websocket_session_ids_for_record_index(1),
            vec![Some("SID-1".to_owned())]
        );
        let websocket_records = websocket_outputs(&snapshot);
        assert_eq!(websocket_records.len(), 2);
        let handshake = websocket_records[0]
            .as_handshake()
            .expect("first WebSocket delivery output should be handshake");
        assert_eq!(handshake.request_id(), "REQ-7");
        assert_eq!(handshake.url().as_str(), "wss://example.com/socket");
        assert_eq!(snapshot.websocket_cursor_advances()[0].record_count(), 2);
        assert_eq!(
            snapshot.websocket_session_ids_for_event_index(0),
            vec![Some("SID-1".to_owned())]
        );
        let frame = websocket_records[1]
            .as_frame()
            .expect("second WebSocket delivery output should be frame");
        assert_eq!(frame.request_id(), "REQ-7");
        assert_eq!(frame.payload_length(), 4);
        assert_eq!(snapshot.websocket_cursor_advances()[0].event_count(), 1);
    }

    #[test]
    fn combined_delivery_snapshot_owns_session_fanout_and_cursor_advances() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket", 7),
            subresource_record(SubresourceResourceType::Fetch, "https://example.com/api"),
        ];
        let events = vec![websocket_event(7, 4)];
        apply_network_items_for_test(&mut output_queue, &records, &events);

        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(Some("SID-1".to_owned()), 1),
        ])
        .expect("subresource session should create activity");
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(Some("SID-1".to_owned()), 1, 0),
        ])
        .expect("WebSocket session should create activity");
        let mut request_ids = TestBacklogRequestIds;

        let snapshot = pending_delivery_snapshot(
            &output_queue,
            Some(subresource_activity),
            Some(websocket_activity),
            &mut request_ids,
        )
        .expect("combined snapshot should include pending outputs");

        assert_eq!(
            snapshot
                .delivery_entries()
                .map(|(item, session_ids)| match item {
                    PendingNetworkBacklogDeliveryItem::Subresource(_) =>
                        format!("subresource:{}", session_ids.len()),
                    PendingNetworkBacklogDeliveryItem::WebSocket(_) =>
                        format!("websocket:{}", session_ids.len()),
                })
                .collect::<Vec<_>>(),
            vec![
                "subresource:1",
                "websocket:1",
                "subresource:1",
                "websocket:1",
            ],
            "snapshot should retain concrete delivery entries with prepared session fanout"
        );
        assert_eq!(
            snapshot.subresource_session_ids_for_record_index(0),
            Vec::<Option<String>>::new(),
            "records before the session cursor must not fan out"
        );
        assert_eq!(
            snapshot.subresource_session_ids_for_record_index(1),
            vec![Some("SID-1".to_owned())],
            "snapshot should own subresource session fanout"
        );
        assert_eq!(
            snapshot.websocket_session_ids_for_event_index(0),
            vec![Some("SID-1".to_owned())],
            "snapshot should own WebSocket event fanout"
        );

        let subresource_advances = snapshot.subresource_cursor_advances();
        assert_eq!(subresource_advances.len(), 1);
        assert_eq!(subresource_advances[0].session_id(), Some("SID-1"));
        assert_eq!(subresource_advances[0].start_index(), 1);
        assert_eq!(
            subresource_advances[0].record_count(),
            2,
            "subresource cursor should advance from record 1 through the fetch at record 2"
        );

        let websocket_advances = snapshot.websocket_cursor_advances();
        assert_eq!(websocket_advances.len(), 1);
        assert_eq!(websocket_advances[0].session_id(), Some("SID-1"));
        assert_eq!(websocket_advances[0].record_start_index(), 1);
        assert_eq!(websocket_advances[0].record_count(), 1);
        assert_eq!(websocket_advances[0].event_start_index(), 0);
        assert_eq!(websocket_advances[0].event_count(), 1);
    }

    #[test]
    fn prepared_backlog_visible_ranges_are_bounded_by_prepare_time_watermarks() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let initial_records = vec![
            subresource_record_with_body("https://example.com/app.js", "prepared-body"),
            websocket_record("wss://example.com/socket-a", 7),
        ];
        let initial_events = vec![websocket_event(7, 4)];
        apply_network_items_for_test(&mut output_queue, &initial_records, &initial_events);

        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );

        let subresource_output = output_queue
            .delivery_outputs
            .subresource_output_mut(0)
            .expect("first subresource output should exist");
        subresource_output.url =
            Url::parse("https://example.com/mutated.js").expect("test URL should parse");
        subresource_output.response_body = Some(SubresourceResponseBody::from_bytes(
            b"mutated-body".to_vec(),
        ));
        let TargetWebSocketDeliveryPlanRecord::Handshake(handshake) = output_queue
            .delivery_outputs
            .websocket_record_mut(0)
            .expect("first WebSocket delivery output should exist")
        else {
            panic!("first WebSocket delivery output should be handshake");
        };
        handshake.handshake.url =
            Url::parse("wss://example.com/mutated-socket").expect("test URL should parse");

        let later_records = [
            initial_records[0].clone(),
            initial_records[1].clone(),
            subresource_record(
                SubresourceResourceType::Fetch,
                "https://example.com/later.png",
            ),
            websocket_record("wss://example.com/socket-b", 8),
        ];
        let later_events = [
            initial_events[0].clone(),
            websocket_event(7, 9),
            websocket_event(8, 11),
        ];
        apply_network_items_for_test(
            &mut output_queue,
            &later_records[initial_records.len()..],
            &later_events[initial_events.len()..],
        );

        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("prepared delivery token should still materialize initial outputs");
        assert_eq!(
            subresource_outputs(&snapshot)
                .iter()
                .map(|output| output.metadata().url().as_str())
                .collect::<Vec<_>>(),
            vec!["https://example.com/app.js", "wss://example.com/socket-a"],
            "prepared subresource token must own prepare-time payload instead of rereading queue slots"
        );
        assert_eq!(
            subresource_outputs(&snapshot)[0]
                .metadata()
                .response_body()
                .expect("prepared success output should own its response body")
                .diagnostic_bytes()
                .as_ref(),
            b"prepared-body",
            "prepared subresource token must own prepare-time body source instead of rereading queue slots"
        );

        assert_eq!(
            websocket_outputs(&snapshot)
                .iter()
                .map(|record| match record {
                    TargetWebSocketDeliveryRecord::Handshake(output) =>
                        format!("handshake:{}", output.url()),
                    TargetWebSocketDeliveryRecord::Frame(output) =>
                        format!("frame:{}", output.payload_length),
                    TargetWebSocketDeliveryRecord::Lifecycle(_) => "lifecycle".to_owned(),
                })
                .collect::<Vec<_>>(),
            vec!["handshake:wss://example.com/socket-a", "frame:4"],
            "prepared WebSocket token must own prepare-time payload instead of rereading queue slots"
        );
        assert_eq!(
            snapshot.subresource_cursor_advances()[0].record_count(),
            2,
            "prepared subresource range should own its prepare-time emitted tail"
        );
        assert_eq!(
            snapshot.websocket_cursor_advances()[0].record_count(),
            2,
            "prepared WebSocket range should own its prepare-time handshake tail"
        );
        assert_eq!(
            snapshot.websocket_cursor_advances()[0].event_count(),
            1,
            "prepared WebSocket range should own its prepare-time frame tail"
        );
    }

    #[test]
    fn prepared_backlog_tokens_are_single_use_slots() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[
                subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                ),
                websocket_record("wss://example.com/socket", 7),
            ],
            &[websocket_event(7, 4)],
        );
        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );
        assert!(
            backlog.has_output(),
            "prepared backlog should expose one activity output while retaining typed token items internally"
        );

        assert!(
            output_queue
                .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
                .is_some(),
            "combined delivery token should materialize once"
        );
        assert!(
            !backlog.has_output(),
            "consuming the combined prepared slot should drain all prepared families"
        );
        assert!(
            output_queue
                .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
                .is_none(),
            "combined delivery token should not materialize twice"
        );
    }

    #[test]
    fn prepared_backlog_extend_merges_delivery_token_families() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[
                subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                ),
                websocket_record("wss://example.com/socket", 7),
            ],
            &[websocket_event(7, 4)],
        );

        let mut subresource_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        let websocket_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(None, Some(0), Some(0)),
        );
        subresource_backlog.extend(websocket_backlog);

        assert!(
            subresource_backlog.has_output(),
            "separate family preparations should merge into one prepared delivery token"
        );
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut subresource_backlog)
            .expect("merged delivery token should still materialize once");
        assert_eq!(
            snapshot
                .outputs()
                .into_iter()
                .map(|output| match output {
                    PendingNetworkBacklogDeliveryItem::Subresource(_) => "subresource",
                    PendingNetworkBacklogDeliveryItem::WebSocket(_) => "websocket",
                })
                .collect::<Vec<_>>(),
            vec!["subresource", "subresource", "websocket", "websocket"],
            "merged prepared token should keep the concrete item order owned by the token"
        );
        assert_eq!(subresource_outputs(&snapshot).len(), 2);
        assert_eq!(websocket_outputs(&snapshot).len(), 2);
        assert!(
            !subresource_backlog.has_output(),
            "consuming the merged delivery token should clear all families"
        );
    }

    #[test]
    fn prepared_backlog_visible_ranges_do_not_materialize_after_queue_reset() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[
                subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/old.js",
                ),
                websocket_record("wss://example.com/old-socket", 7),
            ],
            &[websocket_event(7, 4)],
        );
        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );

        output_queue.reset();
        apply_network_items_for_test(
            &mut output_queue,
            &[
                subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/new.js",
                ),
                websocket_record("wss://example.com/new-socket", 8),
            ],
            &[websocket_event(8, 9)],
        );

        assert!(
            output_queue
                .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
                .is_none(),
            "a prepared combined token from an old queue generation must not materialize new-page output with matching indexes"
        );
    }

    #[test]
    fn stale_prepared_backlog_token_is_consumed_without_current_queue_recovery() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/old.js",
            )],
            &[],
        );
        let mut stale_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        assert!(
            stale_backlog.has_output(),
            "old page should prepare one Network backlog token before reset"
        );

        output_queue.reset();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/new.js",
            )],
            &[],
        );

        assert!(
            output_queue
                .pending_network_backlog_delivery_snapshot_from_backlog(&mut stale_backlog)
                .is_none(),
            "stale prepared tokens must fail closed instead of recovering from the owner queue generation"
        );
        assert!(
            !stale_backlog.has_output(),
            "a stale prepared token should still be consumed once so it cannot busy-loop"
        );

        let fresh_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(Some("SID-fresh".to_owned()), 0),
        ])
        .expect("fresh session should create subresource activity");
        let mut request_ids = TestBacklogRequestIds;
        let fresh_snapshot =
            pending_delivery_snapshot(&output_queue, Some(fresh_activity), None, &mut request_ids)
                .expect("fresh durable owner activity should still deliver owner queue output");
        assert_eq!(
            subresource_outputs(&fresh_snapshot)
                .iter()
                .map(|output| output.metadata().url().as_str())
                .collect::<Vec<_>>(),
            vec!["https://example.com/new.js"],
            "stale prepared-token rejection must not poison the owner queue"
        );
    }

    #[test]
    fn prepared_backlog_extend_keeps_fresh_generation_when_stale_token_is_added_later() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/old.js",
            )],
            &[],
        );
        let stale_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );

        output_queue.reset();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/new.js",
            )],
            &[],
        );
        let mut fresh_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        fresh_backlog.extend(stale_backlog);

        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut fresh_backlog)
            .expect("fresh token should survive extending with a stale generation token");
        assert_eq!(
            subresource_outputs(&snapshot)
                .iter()
                .map(|output| output.metadata().url().as_str())
                .collect::<Vec<_>>(),
            vec!["https://example.com/new.js"],
            "extending prepared outputs must not mix old-generation payload with current-generation payload"
        );
    }

    #[test]
    fn prepared_backlog_extend_replaces_stale_generation_when_fresh_token_is_added_later() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/old.js",
            )],
            &[],
        );
        let mut stale_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );

        output_queue.reset();
        apply_network_items_for_test(
            &mut output_queue,
            &[subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/new.js",
            )],
            &[],
        );
        let fresh_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        stale_backlog.extend(fresh_backlog);

        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut stale_backlog)
            .expect("fresh token should replace an older generation token during merge");
        assert_eq!(
            subresource_outputs(&snapshot)
                .iter()
                .map(|output| output.metadata().url().as_str())
                .collect::<Vec<_>>(),
            vec!["https://example.com/new.js"],
            "prepared-token merge should not depend on stale/fresh operand order"
        );
    }

    #[test]
    fn prepared_backlog_extend_does_not_duplicate_same_family_token_items() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        apply_network_items_for_test(
            &mut output_queue,
            &[
                subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                ),
                websocket_record("wss://example.com/socket", 7),
            ],
            &[websocket_event(7, 4)],
        );

        let mut first_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );
        let duplicate_backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );
        first_backlog.extend(duplicate_backlog);

        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut first_backlog)
            .expect("deduplicated prepared token should materialize once");
        assert_eq!(
            snapshot.outputs().len(),
            4,
            "merging the same prepared backlog twice must not duplicate delivery items"
        );
        assert_eq!(
            subresource_outputs(&snapshot).len(),
            2,
            "duplicate subresource token families should be ignored"
        );
        assert_eq!(
            websocket_outputs(&snapshot).len(),
            2,
            "duplicate WebSocket token families should be ignored"
        );
    }

    #[test]
    fn prepared_backlog_token_preserves_cross_family_producer_order() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ))),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record(
                "wss://example.com/socket",
                7,
            ))),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event(7, 4)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
                SubresourceResourceType::Fetch,
                "https://example.com/api",
            ))),
        ];
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");

        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), Some(0), Some(0)),
        );
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("prepared token should materialize mixed Network/WebSocket output");

        assert_eq!(
            snapshot
                .outputs()
                .into_iter()
                .map(|output| match output {
                    PendingNetworkBacklogDeliveryItem::Subresource(output) =>
                        format!("subresource:{}", output.metadata().url()),
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Handshake(output),
                    ) => format!("websocket-handshake:{}", output.url()),
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Frame(output),
                    ) => format!("websocket-frame:{}", output.payload_length()),
                    PendingNetworkBacklogDeliveryItem::WebSocket(
                        TargetWebSocketDeliveryRecord::Lifecycle(_),
                    ) => "websocket-lifecycle".to_owned(),
                })
                .collect::<Vec<_>>(),
            vec![
                "subresource:https://example.com/app.js",
                "subresource:wss://example.com/socket",
                "websocket-handshake:wss://example.com/socket",
                "websocket-frame:4",
                "subresource:https://example.com/api",
            ],
            "prepared Network backlog must preserve producer append order across subresource and WebSocket families"
        );
    }

    #[test]
    fn websocket_only_prepared_backlog_does_not_materialize_plain_subresources() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(
            &mut output_queue,
            &[
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                ))),
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record(
                    "wss://example.com/socket",
                    7,
                ))),
                ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event(7, 4)),
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
                    SubresourceResourceType::Fetch,
                    "https://example.com/api",
                ))),
            ],
            "LOADER-1",
        );

        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(None, Some(0), Some(0)),
        );
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("websocket-only prepared token should materialize websocket output");

        assert!(
            subresource_outputs(&snapshot).is_empty(),
            "a WebSocket-only cursor must not smuggle ordinary subresource records through the prepared token"
        );
        assert_eq!(
            websocket_outputs(&snapshot)
                .iter()
                .map(|output| match output {
                    TargetWebSocketDeliveryRecord::Handshake(output) =>
                        format!("handshake:{}", output.url()),
                    TargetWebSocketDeliveryRecord::Frame(output) =>
                        format!("frame:{}", output.payload_length()),
                    TargetWebSocketDeliveryRecord::Lifecycle(_) => "lifecycle".to_owned(),
                })
                .collect::<Vec<_>>(),
            vec!["handshake:wss://example.com/socket", "frame:4"],
            "the WebSocket family should still carry both handshake and frame output"
        );
    }

    #[test]
    fn websocket_frame_only_prepared_backlog_advances_event_cursor() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        append_concrete_items_for_test(
            &mut output_queue,
            &[
                ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(subresource_record(
                    SubresourceResourceType::Script,
                    "https://example.com/app.js",
                ))),
                ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event(7, 4)),
            ],
            "LOADER-1",
        );

        let mut backlog = output_queue.backlog_prepared_delivery(
            TargetNetworkBacklogActivityCursor::new(Some(0), None, None),
        );
        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(Some("SID-ws".to_owned()), 0, 0),
        ])
        .expect("session should create WebSocket activity");
        let mut request_ids = TestBacklogRequestIds;
        backlog.extend(output_queue.backlog_prepared_delivery_for_activity(
            None,
            Some(websocket_activity),
            &mut request_ids,
        ));
        let snapshot = output_queue
            .pending_network_backlog_delivery_snapshot_from_backlog(&mut backlog)
            .expect("merged frame-only prepared backlog should materialize pending output");

        assert_eq!(
            websocket_outputs(&snapshot)
                .iter()
                .map(|output| match output {
                    TargetWebSocketDeliveryRecord::Handshake(_) => "handshake",
                    TargetWebSocketDeliveryRecord::Frame(_) => "frame",
                    TargetWebSocketDeliveryRecord::Lifecycle(_) => "lifecycle",
                })
                .collect::<Vec<_>>(),
            vec!["frame"],
            "test fixture should cover a merged WebSocket token with no handshake record output"
        );
        assert_eq!(
            snapshot
                .websocket_cursor_advances()
                .iter()
                .map(|advance| {
                    (
                        advance.session_id().map(str::to_owned),
                        advance.record_start_index(),
                        advance.record_count(),
                        advance.event_start_index(),
                        advance.event_count(),
                    )
                })
                .collect::<Vec<_>>(),
            vec![(Some("SID-ws".to_owned()), 0, 0, 0, 1)],
            "prepared bounds should advance frame-only WebSocket cursors without rescanning delivery payload at emit time"
        );
    }

    #[test]
    fn target_network_output_queue_uses_append_order_for_websocket_delivery() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let items = vec![
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record(
                "wss://example.com/socket-a",
                7,
            ))),
            ScriptNetworkOutputItem::WebSocketNetworkEvent(websocket_event(7, 4)),
            ScriptNetworkOutputItem::SubresourceNetworkRecord(Box::new(websocket_record(
                "wss://example.com/socket-b",
                8,
            ))),
        ];
        append_concrete_items_for_test(&mut output_queue, &items, "LOADER-1");

        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 0, 0),
        ])
        .expect("session should create WebSocket activity");
        let mut request_ids = TestBacklogRequestIds;
        let snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(websocket_activity),
            &mut request_ids,
        )
        .expect("websocket delivery snapshot should contain pending output");

        assert_eq!(
            websocket_outputs(&snapshot)
                .iter()
                .map(|output| match output {
                    TargetWebSocketDeliveryRecord::Handshake(output) =>
                        format!("handshake:{}", output.request_id()),
                    TargetWebSocketDeliveryRecord::Frame(output) =>
                        format!("frame:{}", output.request_id()),
                    TargetWebSocketDeliveryRecord::Lifecycle(output) =>
                        format!("lifecycle:{}", output.request_id()),
                })
                .collect::<Vec<_>>(),
            vec!["handshake:REQ-7", "frame:REQ-7", "handshake:REQ-8"],
            "WebSocket delivery should follow append-time lifecycle order instead of regrouping all handshakes before frames"
        );
    }

    #[test]
    fn target_network_output_queue_delegates_websocket_request_id_binding_to_owner() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![websocket_record("wss://example.com/socket", 7)];
        let events = vec![websocket_event(7, 4)];
        apply_network_items_for_test(&mut output_queue, &records, &events);

        let bindings = RefCell::new(HashMap::<u64, String>::new());
        let lookup_calls = Cell::new(0);
        let allocation_calls = Cell::new(0);
        struct RecordingBacklogRequestIds<'a> {
            bindings: &'a RefCell<HashMap<u64, String>>,
            lookup_calls: &'a Cell<usize>,
            allocation_calls: &'a Cell<usize>,
        }
        impl TargetNetworkBacklogRequestIdResolver for RecordingBacklogRequestIds<'_> {
            fn request_id_for_subresource_output(
                &mut self,
                output: &TargetSubresourcePlanOutput,
            ) -> String {
                let socket_id = output
                    .websocket_socket_id()
                    .expect("test output should be a websocket subresource");
                self.request_id_for_websocket_socket(socket_id)
            }

            fn request_id_for_websocket_socket(&mut self, socket_id: u64) -> String {
                self.lookup_calls.set(self.lookup_calls.get() + 1);
                self.bindings
                    .borrow_mut()
                    .entry(socket_id)
                    .or_insert_with(|| {
                        self.allocation_calls.set(self.allocation_calls.get() + 1);
                        "REQ-from-websocket".to_owned()
                    })
                    .clone()
            }
        }
        let mut request_ids = RecordingBacklogRequestIds {
            bindings: &bindings,
            lookup_calls: &lookup_calls,
            allocation_calls: &allocation_calls,
        };

        let websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 0, 0),
        ])
        .expect("session should create WebSocket activity");
        let websocket_snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(websocket_activity),
            &mut request_ids,
        )
        .expect("websocket delivery snapshot should contain pending output");
        assert_eq!(
            lookup_calls.get(),
            2,
            "queue should delegate both handshake and frame request-id resolution to the owner"
        );
        assert_eq!(
            allocation_calls.get(),
            1,
            "owner should allocate only one request id for one WebSocket socket"
        );
        assert!(
            websocket_outputs(&websocket_snapshot)
                .iter()
                .all(|output| match output {
                    TargetWebSocketDeliveryRecord::Handshake(output) =>
                        output.request_id() == "REQ-from-websocket",
                    TargetWebSocketDeliveryRecord::Frame(output) =>
                        output.request_id() == "REQ-from-websocket",
                    TargetWebSocketDeliveryRecord::Lifecycle(output) =>
                        output.request_id() == "REQ-from-websocket",
                })
        );

        let subresource_activity = PendingSubresourceNetworkActivity::from_sessions(vec![
            PendingSubresourceNetworkActivitySession::new(None, 0),
        ])
        .expect("session should create subresource activity");
        let subresource_snapshot = pending_delivery_snapshot(
            &output_queue,
            Some(subresource_activity),
            None,
            &mut request_ids,
        )
        .expect("subresource delivery snapshot should contain pending output");
        assert_eq!(
            subresource_outputs(&subresource_snapshot)[0].request_id(),
            "REQ-from-websocket",
            "subresource delivery should reuse the owner-level WebSocket request id binding"
        );
        assert_eq!(
            lookup_calls.get(),
            3,
            "subresource delivery should also resolve WebSocket request id through the owner"
        );
        assert_eq!(
            allocation_calls.get(),
            1,
            "cross-family request id reuse should come from the owner binding, not queue-local lifecycle cache"
        );

        let late_websocket_activity = PendingWebSocketNetworkActivity::from_sessions(vec![
            PendingWebSocketNetworkActivitySession::new(None, 0, 0),
        ])
        .expect("session should create WebSocket activity");
        let late_snapshot = pending_delivery_snapshot(
            &output_queue,
            None,
            Some(late_websocket_activity),
            &mut request_ids,
        )
        .expect("late websocket delivery snapshot should contain pending output");
        assert!(
            websocket_outputs(&late_snapshot)
                .iter()
                .all(|output| match output {
                    TargetWebSocketDeliveryRecord::Handshake(output) =>
                        output.request_id() == "REQ-from-websocket",
                    TargetWebSocketDeliveryRecord::Frame(output) =>
                        output.request_id() == "REQ-from-websocket",
                    TargetWebSocketDeliveryRecord::Lifecycle(output) =>
                        output.request_id() == "REQ-from-websocket",
                })
        );
        assert_eq!(
            lookup_calls.get(),
            5,
            "late replay should delegate request-id resolution again instead of using queue-local cache"
        );
        assert_eq!(
            allocation_calls.get(),
            1,
            "late replay should still reuse owner binding without allocating a second id"
        );
    }

    #[test]
    fn websocket_handshake_backlog_presence_tracks_sparse_delivery_outputs() {
        let mut output_queue = TargetNetworkOutputQueue::default();
        let records = vec![
            websocket_record("wss://example.com/socket-a", 7),
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
        ];
        apply_network_items_for_test(&mut output_queue, &records, &[]);

        assert!(
            output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    None,
                    Some(0),
                    None,
                ))
                .has_output(),
            "a listener cursor before the latest handshake record should see handshake backlog"
        );
        assert!(
            !output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    None,
                    Some(1),
                    None,
                ))
                .has_output(),
            "plain subresource records after the last WebSocket handshake must not keep the handshake family dirty"
        );

        let records = vec![
            websocket_record("wss://example.com/socket-a", 7),
            subresource_record(
                SubresourceResourceType::Script,
                "https://example.com/app.js",
            ),
            websocket_record("wss://example.com/socket-b", 8),
        ];
        apply_network_items_for_test(&mut output_queue, &records, &[]);
        assert!(
            output_queue
                .backlog_prepared_delivery(TargetNetworkBacklogActivityCursor::new(
                    None,
                    Some(1),
                    None,
                ))
                .has_output(),
            "a later sparse WebSocket handshake should reopen the handshake family for caught-up listeners"
        );
    }
}