guise-ui 1.5.2

//! The record store behind every devtools panel.
//!
//! Safari's Web Inspector reads a live page; there is no equivalent firehose in
//! a native app, so `guise` inverts it: the host *reports* what it does — a log
//! line, a request, a storage domain — and this global keeps the rolling
//! history the panels render. Nothing here opens a socket or reads a file, the
//! same way [`crate::ai`] never issues the request it displays.
//!
//! Every store is a ring: capped, oldest-first eviction, so a long-running app
//! cannot grow the inspector without bound. `generation` ticks on every
//! mutation, which is what lets a panel skip work when nothing changed.

use std::collections::VecDeque;
use std::time::{Duration, Instant};

use gpui::{App, Global, SharedString};

/// Where a record came from in the source. Built from a gpui element's
/// `#[track_caller]` location, or supplied by the host for its own records.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SourceRef {
  pub file: SharedString,
  pub line: u32,
  pub column: u32,
}

impl SourceRef {
  pub fn new(file: impl Into<SharedString>, line: u32, column: u32) -> Self {
    SourceRef {
      file: file.into(),
      line,
      column,
    }
  }

  /// Just the file name, which is all the one-line displays have room for.
  pub fn basename(&self) -> &str {
    let file = self.file.as_ref();
    match file.rsplit_once('/') {
      Some((_, name)) => name,
      None => file,
    }
  }

  /// `foo.rs:12:5`, the form both Safari and rustc print.
  pub fn short(&self) -> String {
    format!("{}:{}:{}", self.basename(), self.line, self.column)
  }
}

impl From<&'static std::panic::Location<'static>> for SourceRef {
  fn from(loc: &'static std::panic::Location<'static>) -> Self {
    SourceRef::new(loc.file(), loc.line(), loc.column())
  }
}

/// Log severity. Mirrors the levels Safari's console filters by.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum LogLevel {
  /// `console.log` — no icon, no color.
  #[default]
  Log,
  /// `console.debug` — dimmed.
  Debug,
  /// `console.info` — blue dot.
  Info,
  /// `console.warn` — amber, counted in the toolbar.
  Warning,
  /// `console.error` — red, counted in the toolbar.
  Error,
}

impl LogLevel {
  pub fn label(self) -> &'static str {
    match self {
      LogLevel::Log => "Log",
      LogLevel::Debug => "Debug",
      LogLevel::Info => "Info",
      LogLevel::Warning => "Warning",
      LogLevel::Error => "Error",
    }
  }

  /// Whether the toolbar's warning/error badges count this level.
  pub fn is_issue(self) -> bool {
    matches!(self, LogLevel::Warning | LogLevel::Error)
  }
}

/// One log line. `count` is the repeat tally: Safari collapses identical
/// consecutive messages into a single row with a counter rather than scrolling
/// the useful history away, and so do we.
#[derive(Debug, Clone)]
pub struct LogRecord {
  pub id: u64,
  pub level: LogLevel,
  pub message: SharedString,
  /// Expandable key/value rows shown when the row is disclosed — the native
  /// stand-in for expanding a logged object.
  pub details: Vec<(SharedString, SharedString)>,
  pub source: Option<SourceRef>,
  pub at: Duration,
  pub count: usize,
}

impl LogRecord {
  pub fn new(level: LogLevel, message: impl Into<SharedString>) -> Self {
    LogRecord {
      id: 0,
      level,
      message: message.into(),
      details: Vec::new(),
      source: None,
      at: Duration::ZERO,
      count: 1,
    }
  }

  pub fn detail(mut self, key: impl Into<SharedString>, value: impl Into<SharedString>) -> Self {
    self.details.push((key.into(), value.into()));
    self
  }

  pub fn details(mut self, rows: impl IntoIterator<Item = (SharedString, SharedString)>) -> Self {
    self.details.extend(rows);
    self
  }

  pub fn source(mut self, source: SourceRef) -> Self {
    self.source = Some(source);
    self
  }

  /// Two records coalesce when they would render identically.
  fn same_as(&self, other: &LogRecord) -> bool {
    self.level == other.level && self.message == other.message && self.details == other.details
  }
}

/// What kind of resource a request fetched. Drives the Network panel's type
/// filter and the waterfall color, exactly as in Safari.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum ResourceKind {
  Document,
  Stylesheet,
  Image,
  Font,
  Script,
  /// `XHR` and `fetch` in Safari; any app-level API call here.
  Fetch,
  WebSocket,
  Media,
  #[default]
  Other,
}

impl ResourceKind {
  pub fn label(self) -> &'static str {
    match self {
      ResourceKind::Document => "Document",
      ResourceKind::Stylesheet => "Stylesheet",
      ResourceKind::Image => "Image",
      ResourceKind::Font => "Font",
      ResourceKind::Script => "Script",
      ResourceKind::Fetch => "Fetch",
      ResourceKind::WebSocket => "Socket",
      ResourceKind::Media => "Media",
      ResourceKind::Other => "Other",
    }
  }

  /// The set the Network panel's type filter offers, in Safari's order.
  pub const ALL: [ResourceKind; 9] = [
    ResourceKind::Document,
    ResourceKind::Stylesheet,
    ResourceKind::Image,
    ResourceKind::Font,
    ResourceKind::Script,
    ResourceKind::Fetch,
    ResourceKind::WebSocket,
    ResourceKind::Media,
    ResourceKind::Other,
  ];
}

/// The phase breakdown behind the waterfall bar. Each field is the time spent
/// in that phase, not a timestamp, so a partially-complete request is just one
/// with later phases still zero.
#[derive(Debug, Clone, Copy, Default, PartialEq)]
pub struct Timings {
  pub stalled: Duration,
  pub dns: Duration,
  pub connect: Duration,
  pub tls: Duration,
  pub request: Duration,
  pub response: Duration,
}

impl Timings {
  pub fn total(&self) -> Duration {
    self.stalled + self.dns + self.connect + self.tls + self.request + self.response
  }

  /// The phases in waterfall order, skipping the ones that took no time.
  pub fn phases(&self) -> Vec<(&'static str, Duration)> {
    [
      ("Stalled", self.stalled),
      ("DNS", self.dns),
      ("Connect", self.connect),
      ("Secure", self.tls),
      ("Request", self.request),
      ("Response", self.response),
    ]
    .into_iter()
    .filter(|(_, d)| !d.is_zero())
    .collect()
  }
}

/// How far along a request is. A record starts `Pending` and the host settles
/// it later by id — the inspector shows the row the whole time, as Safari does.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum RequestState {
  #[default]
  Pending,
  Finished,
  Failed,
  Canceled,
}

/// One network request.
#[derive(Debug, Clone)]
pub struct NetworkRecord {
  pub id: u64,
  pub method: SharedString,
  pub url: SharedString,
  pub kind: ResourceKind,
  pub state: RequestState,
  pub status: Option<u16>,
  pub status_text: SharedString,
  pub protocol: SharedString,
  pub remote_address: SharedString,
  pub priority: SharedString,
  /// Bytes on the wire, after compression.
  pub transfer_size: u64,
  /// Bytes after decoding — what the app actually received.
  pub resource_size: u64,
  pub cached: bool,
  pub request_headers: Vec<(SharedString, SharedString)>,
  pub response_headers: Vec<(SharedString, SharedString)>,
  pub request_body: Option<SharedString>,
  pub response_body: Option<SharedString>,
  pub initiator: Option<SourceRef>,
  pub error: Option<SharedString>,
  /// When the request started, relative to the store's epoch. The waterfall
  /// lays rows out against this.
  pub start: Duration,
  pub timings: Timings,
}

impl NetworkRecord {
  pub fn new(method: impl Into<SharedString>, url: impl Into<SharedString>) -> Self {
    NetworkRecord {
      id: 0,
      method: method.into(),
      url: url.into(),
      kind: ResourceKind::default(),
      state: RequestState::Pending,
      status: None,
      status_text: SharedString::default(),
      protocol: SharedString::default(),
      remote_address: SharedString::default(),
      priority: SharedString::default(),
      transfer_size: 0,
      resource_size: 0,
      cached: false,
      request_headers: Vec::new(),
      response_headers: Vec::new(),
      request_body: None,
      response_body: None,
      initiator: None,
      error: None,
      start: Duration::ZERO,
      timings: Timings::default(),
    }
  }

  pub fn kind(mut self, kind: ResourceKind) -> Self {
    self.kind = kind;
    self
  }

  pub fn status(mut self, status: u16, text: impl Into<SharedString>) -> Self {
    self.status = Some(status);
    self.status_text = text.into();
    self
  }

  pub fn sizes(mut self, transfer: u64, resource: u64) -> Self {
    self.transfer_size = transfer;
    self.resource_size = resource;
    self
  }

  pub fn timings(mut self, timings: Timings) -> Self {
    self.timings = timings;
    self
  }

  pub fn request_header(
    mut self,
    name: impl Into<SharedString>,
    value: impl Into<SharedString>,
  ) -> Self {
    self.request_headers.push((name.into(), value.into()));
    self
  }

  pub fn response_header(
    mut self,
    name: impl Into<SharedString>,
    value: impl Into<SharedString>,
  ) -> Self {
    self.response_headers.push((name.into(), value.into()));
    self
  }

  pub fn request_body(mut self, body: impl Into<SharedString>) -> Self {
    self.request_body = Some(body.into());
    self
  }

  pub fn response_body(mut self, body: impl Into<SharedString>) -> Self {
    self.response_body = Some(body.into());
    self
  }

  pub fn initiator(mut self, source: SourceRef) -> Self {
    self.initiator = Some(source);
    self
  }

  pub fn finished(mut self) -> Self {
    self.state = RequestState::Finished;
    self
  }

  pub fn failed(mut self, error: impl Into<SharedString>) -> Self {
    self.state = RequestState::Failed;
    self.error = Some(error.into());
    self
  }

  /// The Name column: the last path segment, or the host for a bare origin.
  pub fn name(&self) -> &str {
    let url = self.url.as_ref();
    let path = url
      .split_once("://")
      .map(|(_, rest)| rest)
      .unwrap_or(url)
      .split(['?', '#'])
      .next()
      .unwrap_or("");
    match path.rsplit_once('/') {
      Some((_, last)) if !last.is_empty() => last,
      _ => path.split('/').next().unwrap_or(url),
    }
  }

  /// The Domain column.
  pub fn domain(&self) -> &str {
    let url = self.url.as_ref();
    let rest = url.split_once("://").map(|(_, r)| r).unwrap_or(url);
    rest.split(['/', '?', '#']).next().unwrap_or(rest)
  }

  /// The Scheme column.
  pub fn scheme(&self) -> &str {
    self
      .url
      .as_ref()
      .split_once("://")
      .map(|(s, _)| s)
      .unwrap_or("")
  }

  /// Whether the row renders in the error color: a transport failure, or any
  /// 4xx/5xx response.
  pub fn is_error(&self) -> bool {
    self.state == RequestState::Failed || self.status.is_some_and(|s| s >= 400)
  }

  pub fn duration(&self) -> Duration {
    self.timings.total()
  }
}

/// What a storage domain holds. Only affects the icon and the sidebar grouping.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum StorageKind {
  /// Persisted settings — the native analogue of Local Storage.
  #[default]
  Local,
  /// In-memory state that dies with the process.
  Session,
  Cookies,
  /// A structured store: a database, an index.
  Database,
  Cache,
}

impl StorageKind {
  pub fn label(self) -> &'static str {
    match self {
      StorageKind::Local => "Local Storage",
      StorageKind::Session => "Session Storage",
      StorageKind::Cookies => "Cookies",
      StorageKind::Database => "Databases",
      StorageKind::Cache => "Caches",
    }
  }
}

/// One row in a storage domain.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StorageEntry {
  pub key: SharedString,
  pub value: SharedString,
  /// Extra columns — cookie domain/path/expiry, a record's type, and so on.
  pub extra: Vec<(SharedString, SharedString)>,
}

impl StorageEntry {
  pub fn new(key: impl Into<SharedString>, value: impl Into<SharedString>) -> Self {
    StorageEntry {
      key: key.into(),
      value: value.into(),
      extra: Vec::new(),
    }
  }

  pub fn extra(mut self, name: impl Into<SharedString>, value: impl Into<SharedString>) -> Self {
    self.extra.push((name.into(), value.into()));
    self
  }
}

/// A named collection of storage rows, listed in the Storage panel's sidebar.
#[derive(Debug, Clone)]
pub struct StorageDomain {
  pub id: SharedString,
  pub name: SharedString,
  pub kind: StorageKind,
  pub entries: Vec<StorageEntry>,
  /// Extra column headers beyond Key and Value.
  pub columns: Vec<SharedString>,
}

impl StorageDomain {
  pub fn new(id: impl Into<SharedString>, name: impl Into<SharedString>) -> Self {
    StorageDomain {
      id: id.into(),
      name: name.into(),
      kind: StorageKind::default(),
      entries: Vec::new(),
      columns: Vec::new(),
    }
  }

  pub fn kind(mut self, kind: StorageKind) -> Self {
    self.kind = kind;
    self
  }

  pub fn columns(mut self, columns: impl IntoIterator<Item = SharedString>) -> Self {
    self.columns = columns.into_iter().collect();
    self
  }

  pub fn entry(mut self, entry: StorageEntry) -> Self {
    self.entries.push(entry);
    self
  }

  pub fn entries(mut self, entries: impl IntoIterator<Item = StorageEntry>) -> Self {
    self.entries.extend(entries);
    self
  }

  /// Total bytes, as the Storage panel's footer reports.
  pub fn size(&self) -> u64 {
    self
      .entries
      .iter()
      .map(|e| (e.key.len() + e.value.len()) as u64)
      .sum()
  }
}

/// A band on the Timelines panel.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub enum TimelineKind {
  /// A rendered frame — the band that reveals dropped frames.
  #[default]
  Frame,
  Layout,
  Paint,
  /// App work: a handler, a task, a computation.
  Script,
  Network,
}

impl TimelineKind {
  pub fn label(self) -> &'static str {
    match self {
      TimelineKind::Frame => "Frames",
      TimelineKind::Layout => "Layout",
      TimelineKind::Paint => "Rendering",
      TimelineKind::Script => "JavaScript & Events",
      TimelineKind::Network => "Network Requests",
    }
  }

  pub const ALL: [TimelineKind; 5] = [
    TimelineKind::Frame,
    TimelineKind::Layout,
    TimelineKind::Paint,
    TimelineKind::Script,
    TimelineKind::Network,
  ];
}

/// One span on a timeline band.
#[derive(Debug, Clone)]
pub struct TimelineEvent {
  pub id: u64,
  pub kind: TimelineKind,
  pub label: SharedString,
  pub start: Duration,
  pub duration: Duration,
  pub source: Option<SourceRef>,
}

impl TimelineEvent {
  pub fn new(kind: TimelineKind, label: impl Into<SharedString>, duration: Duration) -> Self {
    TimelineEvent {
      id: 0,
      kind,
      label: label.into(),
      start: Duration::ZERO,
      duration,
      source: None,
    }
  }

  pub fn end(&self) -> Duration {
    self.start + self.duration
  }
}

/// How many records each store keeps before evicting the oldest.
#[derive(Debug, Clone, Copy)]
pub struct Limits {
  pub logs: usize,
  pub network: usize,
  pub timeline: usize,
}

impl Default for Limits {
  fn default() -> Self {
    Limits {
      logs: 1000,
      network: 1000,
      timeline: 4000,
    }
  }
}

/// Everything the inspector displays, and the only mutable state it owns.
///
/// Installed once with [`DevToolsState::init`]; feed it through the free
/// functions in [`crate::devtools`] (`console_log`, `network_begin`, …), which
/// are no-ops when it was never installed. That is deliberate: instrumentation
/// left in a release build costs a global lookup and nothing more.
pub struct DevToolsState {
  epoch: Instant,
  next_id: u64,
  generation: u64,
  limits: Limits,
  logs: VecDeque<LogRecord>,
  network: VecDeque<NetworkRecord>,
  timeline: VecDeque<TimelineEvent>,
  storage: Vec<StorageDomain>,
  /// Wall-clock frame durations, newest last — the Timelines FPS graph.
  frames: VecDeque<Duration>,
  last_frame: Option<Instant>,
}

impl Global for DevToolsState {}

impl Default for DevToolsState {
  fn default() -> Self {
    DevToolsState::new()
  }
}

impl DevToolsState {
  pub fn new() -> Self {
    DevToolsState {
      epoch: Instant::now(),
      next_id: 1,
      generation: 0,
      limits: Limits::default(),
      logs: VecDeque::new(),
      network: VecDeque::new(),
      timeline: VecDeque::new(),
      storage: Vec::new(),
      frames: VecDeque::new(),
      last_frame: None,
    }
  }

  pub fn limits(mut self, limits: Limits) -> Self {
    self.limits = limits;
    self
  }

  /// Install as the app global. Call once at startup, before opening
  /// [`crate::devtools::DevTools`].
  pub fn init(self, cx: &mut App) {
    cx.set_global(self);
  }

  /// Bumped on every mutation, so a panel can tell "nothing changed" cheaply.
  pub fn generation(&self) -> u64 {
    self.generation
  }

  /// Time since the store was created — the clock every record is stamped on.
  pub fn now(&self) -> Duration {
    self.epoch.elapsed()
  }

  fn tick(&mut self) -> u64 {
    self.generation += 1;
    let id = self.next_id;
    self.next_id += 1;
    id
  }

  // --- logs ---------------------------------------------------------------

  /// Append a line, coalescing it into the previous one when identical.
  pub fn push_log(&mut self, mut record: LogRecord) {
    if let Some(last) = self.logs.back_mut() {
      if last.same_as(&record) {
        last.count += 1;
        self.generation += 1;
        return;
      }
    }
    record.id = self.tick();
    record.at = self.now();
    self.logs.push_back(record);
    while self.logs.len() > self.limits.logs {
      self.logs.pop_front();
    }
  }

  pub fn logs(&self) -> &VecDeque<LogRecord> {
    &self.logs
  }

  pub fn clear_logs(&mut self) {
    self.logs.clear();
    self.generation += 1;
  }

  /// Warning and error tallies for the toolbar badges.
  pub fn log_issues(&self) -> (usize, usize) {
    let mut warnings = 0;
    let mut errors = 0;
    for record in &self.logs {
      match record.level {
        LogLevel::Warning => warnings += record.count,
        LogLevel::Error => errors += record.count,
        _ => {}
      }
    }
    (warnings, errors)
  }

  // --- network -----------------------------------------------------------

  /// Record a request that has started. Returns its id, which the host keeps
  /// to settle the request later.
  pub fn push_network(&mut self, mut record: NetworkRecord) -> u64 {
    let id = self.tick();
    record.id = id;
    if record.start.is_zero() {
      record.start = self.now();
    }
    self.network.push_back(record);
    while self.network.len() > self.limits.network {
      self.network.pop_front();
    }
    id
  }

  /// Amend a request in flight — the response landed, the transfer grew, it
  /// failed. Silently does nothing if the record was already evicted.
  pub fn update_network(&mut self, id: u64, f: impl FnOnce(&mut NetworkRecord)) {
    if let Some(record) = self.network.iter_mut().find(|r| r.id == id) {
      f(record);
      self.generation += 1;
    }
  }

  pub fn network(&self) -> &VecDeque<NetworkRecord> {
    &self.network
  }

  pub fn clear_network(&mut self) {
    self.network.clear();
    self.generation += 1;
  }

  /// The window the waterfall is drawn against: earliest start to latest end.
  pub fn network_span(&self) -> (Duration, Duration) {
    let start = self
      .network
      .iter()
      .map(|r| r.start)
      .min()
      .unwrap_or(Duration::ZERO);
    let end = self
      .network
      .iter()
      .map(|r| r.start + r.duration())
      .max()
      .unwrap_or(Duration::ZERO);
    (start, end.max(start))
  }

  /// Row count, total transfer, and total resource bytes — the status bar.
  pub fn network_totals(&self) -> (usize, u64, u64) {
    let transfer = self.network.iter().map(|r| r.transfer_size).sum();
    let resource = self.network.iter().map(|r| r.resource_size).sum();
    (self.network.len(), transfer, resource)
  }

  // --- storage -----------------------------------------------------------

  /// Register a domain, replacing any existing one with the same id. Hosts
  /// call this whenever their store changes; the panel always shows the
  /// latest snapshot.
  pub fn set_storage(&mut self, domain: StorageDomain) {
    self.generation += 1;
    match self.storage.iter_mut().find(|d| d.id == domain.id) {
      Some(existing) => *existing = domain,
      None => self.storage.push(domain),
    }
  }

  pub fn remove_storage(&mut self, id: &str) {
    self.storage.retain(|d| d.id.as_ref() != id);
    self.generation += 1;
  }

  pub fn storage(&self) -> &[StorageDomain] {
    &self.storage
  }

  // --- timelines ---------------------------------------------------------

  pub fn push_timeline(&mut self, mut event: TimelineEvent) {
    event.id = self.tick();
    if event.start.is_zero() {
      event.start = self.now().saturating_sub(event.duration);
    }
    self.timeline.push_back(event);
    while self.timeline.len() > self.limits.timeline {
      self.timeline.pop_front();
    }
  }

  pub fn timeline(&self) -> &VecDeque<TimelineEvent> {
    &self.timeline
  }

  pub fn clear_timeline(&mut self) {
    self.timeline.clear();
    self.frames.clear();
    self.last_frame = None;
    self.generation += 1;
  }

  /// Called once per rendered frame by the inspector itself. Deriving the
  /// interval here — rather than asking the host to report it — is what makes
  /// the Frames band work with no wiring at all.
  pub fn record_frame(&mut self) {
    let now = Instant::now();
    if let Some(previous) = self.last_frame.replace(now) {
      let delta = now.duration_since(previous);
      // A frame gap longer than a second means the window was idle, not
      // slow; counting it would flatten the graph for minutes.
      if delta < Duration::from_secs(1) {
        self.frames.push_back(delta);
        while self.frames.len() > 240 {
          self.frames.pop_front();
        }
      }
    }
  }

  /// Forget where the last frame landed. Called when recording stops so the
  /// idle gap before it resumes is not measured as one enormous frame.
  pub fn stop_frames(&mut self) {
    self.last_frame = None;
  }

  pub fn frames(&self) -> &VecDeque<Duration> {
    &self.frames
  }

  /// Frames per second over the recorded window, or `None` before the second
  /// frame has been seen.
  pub fn fps(&self) -> Option<f32> {
    if self.frames.is_empty() {
      return None;
    }
    let total: Duration = self.frames.iter().sum();
    if total.is_zero() {
      return None;
    }
    Some(self.frames.len() as f32 / total.as_secs_f32())
  }

  /// Drop every record. The toolbar's clear button, and what a host calls
  /// when it wants a clean slate around a reproduction.
  pub fn clear_all(&mut self) {
    self.logs.clear();
    self.network.clear();
    self.timeline.clear();
    self.frames.clear();
    self.last_frame = None;
    self.generation += 1;
  }
}

/// Format a byte count the way Safari's size columns do.
pub fn format_bytes(bytes: u64) -> String {
  const KB: f64 = 1024.0;
  let bytes = bytes as f64;
  if bytes < KB {
    format!("{} B", bytes as u64)
  } else if bytes < KB * KB {
    format!("{:.1} KB", bytes / KB)
  } else if bytes < KB * KB * KB {
    format!("{:.2} MB", bytes / (KB * KB))
  } else {
    format!("{:.2} GB", bytes / (KB * KB * KB))
  }
}

/// Format a duration the way Safari's timing columns do: sub-millisecond work
/// still reads as a number, and anything past a second switches unit.
pub fn format_duration(duration: Duration) -> String {
  let ms = duration.as_secs_f64() * 1000.0;
  if ms < 1.0 {
    format!("{:.2} ms", ms)
  } else if ms < 1000.0 {
    format!("{:.0} ms", ms)
  } else {
    format!("{:.2} s", ms / 1000.0)
  }
}

/// Elapsed time as the log's timestamp column shows it.
pub fn format_timestamp(at: Duration) -> String {
  let total = at.as_secs();
  let minutes = total / 60;
  let seconds = total % 60;
  format!("{:02}:{:02}.{:03}", minutes, seconds, at.subsec_millis())
}

#[cfg(test)]
mod tests {
  use super::*;

  #[test]
  fn identical_log_lines_coalesce() {
    let mut state = DevToolsState::new();
    state.push_log(LogRecord::new(LogLevel::Warning, "slow frame"));
    state.push_log(LogRecord::new(LogLevel::Warning, "slow frame"));
    state.push_log(LogRecord::new(LogLevel::Warning, "slow frame"));

    assert_eq!(state.logs().len(), 1);
    assert_eq!(state.logs()[0].count, 3);
    assert_eq!(state.log_issues(), (3, 0));
  }

  #[test]
  fn a_different_line_breaks_the_run() {
    let mut state = DevToolsState::new();
    state.push_log(LogRecord::new(LogLevel::Log, "a"));
    state.push_log(LogRecord::new(LogLevel::Log, "b"));
    state.push_log(LogRecord::new(LogLevel::Log, "a"));

    assert_eq!(state.logs().len(), 3);
    assert!(state.logs().iter().all(|r| r.count == 1));
  }

  #[test]
  fn logs_evict_oldest_past_the_limit() {
    let mut state = DevToolsState::new().limits(Limits {
      logs: 3,
      ..Limits::default()
    });
    for i in 0..6 {
      state.push_log(LogRecord::new(LogLevel::Log, format!("line {i}")));
    }

    assert_eq!(state.logs().len(), 3);
    assert_eq!(state.logs()[0].message.as_ref(), "line 3");
    assert_eq!(state.logs()[2].message.as_ref(), "line 5");
  }

  #[test]
  fn a_request_settles_by_id() {
    let mut state = DevToolsState::new();
    let id = state.push_network(NetworkRecord::new(
      "GET",
      "https://api.example.com/v1/users",
    ));
    assert_eq!(state.network()[0].state, RequestState::Pending);

    state.update_network(id, |record| {
      record.state = RequestState::Finished;
      record.status = Some(200);
    });

    assert_eq!(state.network()[0].state, RequestState::Finished);
    assert_eq!(state.network()[0].status, Some(200));
  }

  #[test]
  fn settling_an_evicted_request_is_a_no_op() {
    let mut state = DevToolsState::new().limits(Limits {
      network: 1,
      ..Limits::default()
    });
    let first = state.push_network(NetworkRecord::new("GET", "https://example.com/a"));
    state.push_network(NetworkRecord::new("GET", "https://example.com/b"));

    state.update_network(first, |record| record.status = Some(500));

    assert_eq!(state.network().len(), 1);
    assert_eq!(state.network()[0].status, None);
  }

  #[test]
  fn url_splits_into_name_domain_and_scheme() {
    let record = NetworkRecord::new("GET", "https://api.example.com/v1/users?page=2");
    assert_eq!(record.name(), "users");
    assert_eq!(record.domain(), "api.example.com");
    assert_eq!(record.scheme(), "https");

    let root = NetworkRecord::new("GET", "https://example.com/");
    assert_eq!(root.domain(), "example.com");

    let bare = NetworkRecord::new("GET", "https://example.com");
    assert_eq!(bare.name(), "example.com");
  }

  #[test]
  fn errors_are_status_or_transport() {
    assert!(NetworkRecord::new("GET", "/a")
      .status(404, "Not Found")
      .is_error());
    assert!(NetworkRecord::new("GET", "/a")
      .status(500, "Server Error")
      .is_error());
    assert!(!NetworkRecord::new("GET", "/a")
      .status(304, "Not Modified")
      .is_error());
    assert!(NetworkRecord::new("GET", "/a").failed("offline").is_error());
  }

  #[test]
  fn timings_sum_and_drop_empty_phases() {
    let timings = Timings {
      dns: Duration::from_millis(4),
      connect: Duration::from_millis(11),
      response: Duration::from_millis(35),
      ..Timings::default()
    };

    assert_eq!(timings.total(), Duration::from_millis(50));
    assert_eq!(
      timings.phases().iter().map(|(n, _)| *n).collect::<Vec<_>>(),
      vec!["DNS", "Connect", "Response"]
    );
  }

  #[test]
  fn registering_a_storage_domain_twice_replaces_it() {
    let mut state = DevToolsState::new();
    state
      .set_storage(StorageDomain::new("prefs", "Preferences").entry(StorageEntry::new("a", "1")));
    state.set_storage(
      StorageDomain::new("prefs", "Preferences")
        .entry(StorageEntry::new("a", "2"))
        .entry(StorageEntry::new("b", "3")),
    );

    assert_eq!(state.storage().len(), 1);
    assert_eq!(state.storage()[0].entries.len(), 2);
    assert_eq!(state.storage()[0].entries[0].value.as_ref(), "2");
  }

  #[test]
  fn network_span_covers_every_row() {
    let mut state = DevToolsState::new();
    let mut first = NetworkRecord::new("GET", "/a");
    first.start = Duration::from_millis(100);
    first.timings.response = Duration::from_millis(50);
    let mut second = NetworkRecord::new("GET", "/b");
    second.start = Duration::from_millis(20);
    second.timings.response = Duration::from_millis(10);
    state.push_network(first);
    state.push_network(second);

    let (start, end) = state.network_span();
    assert_eq!(start, Duration::from_millis(20));
    assert_eq!(end, Duration::from_millis(150));
  }

  #[test]
  fn byte_and_duration_formats_match_the_columns() {
    assert_eq!(format_bytes(512), "512 B");
    assert_eq!(format_bytes(2048), "2.0 KB");
    assert_eq!(format_bytes(5 * 1024 * 1024), "5.00 MB");

    assert_eq!(format_duration(Duration::from_micros(250)), "0.25 ms");
    assert_eq!(format_duration(Duration::from_millis(42)), "42 ms");
    assert_eq!(format_duration(Duration::from_millis(1500)), "1.50 s");

    assert_eq!(format_timestamp(Duration::from_millis(63_042)), "01:03.042");
  }

  #[test]
  fn source_refs_shorten_to_basename() {
    let source = SourceRef::new("crates/guise/src/button.rs", 42, 9);
    assert_eq!(source.basename(), "button.rs");
    assert_eq!(source.short(), "button.rs:42:9");
  }
}