@recombine-ai/bosun 0.9.0 → 0.10.0

package/build/server/chunks/_page.svelte-BhU1G2ip.js

@@ -0,0 +1,1040 @@
+import { j as escape_html, l as derived, n as ensure_array_like, q as attr_style } from './index-CSpGrMM2.js';
+import { o as onDestroy } from './index-server-DsYEXu5n.js';
+import { p as page } from './index2-DO4B3D-P.js';
+import { B as Button } from './Button-Dsy3QY7B.js';
+import { g as getPersistedTelescopeSourceId } from './source-selection-eA--VEKo.js';
+import './state.svelte-DT7cgvTK.js';
+import './root-CDJwhpIB.js';
+import './events-BQ65tUJo.js';
+import './index3-qVi61CNf.js';
+import 'zod';
+
+function _page($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const TIMELINE_RULER_HEIGHT_PX = 32;
+    const TIMELINE_ROW_HEIGHT_PX = 40;
+    const WAVEFORM_ROW_HEIGHT_PX = 160;
+    const TIMELINE_SCALE_HEIGHT_PX = 32;
+    const BOSUN_COLORS = {
+      blue: "#569cd6",
+      green: "#93FF6D",
+      greenDark: "#00B58A",
+      orange: "#ce9178",
+      purple: "#81147D",
+      red: "#FF6666",
+      gray: "#767676"
+    };
+    const ROW_DEFS = [
+      { label: "Call", eventTypes: ["call.started", "call.ended"] },
+      {
+        label: "VAD",
+        eventTypes: ["vad.activated", "vad.deactivated"]
+      },
+      {
+        label: "STT",
+        eventTypes: ["stt.started", "stt.interim", "stt.final"]
+      },
+      { label: "Trigger", eventTypes: ["speech.created"] },
+      {
+        label: "Reply Pending",
+        eventTypes: ["reply.pending.started", "reply.pending.completed"]
+      },
+      {
+        label: "LLM Transport",
+        eventTypes: [
+          "llm.connect_tcp.started",
+          "llm.connect_tcp.completed",
+          "llm.connect_tcp.failed",
+          "llm.start_tls.started",
+          "llm.start_tls.completed",
+          "llm.start_tls.failed"
+        ]
+      },
+      {
+        label: "LLM Wait",
+        eventTypes: ["llm.wait.started", "llm.requested", "llm.wait.completed"]
+      },
+      {
+        label: "LLM Stream",
+        eventTypes: [
+          "llm.stream.started",
+          "llm.first_token",
+          "llm.completed",
+          "llm.stream.completed"
+        ]
+      },
+      {
+        label: "TTS Text",
+        eventTypes: ["tts.text.first_sent", "tts.text.completed"]
+      },
+      {
+        label: "Provider",
+        eventTypes: [
+          "tts.provider.started",
+          "tts.audio.first_received",
+          "tts.audio.last_received",
+          "tts.provider.completed"
+        ]
+      },
+      {
+        label: "Decode",
+        eventTypes: ["tts.decode.started", "tts.decode.completed"]
+      },
+      {
+        label: "Output Queue",
+        eventTypes: ["audio.output.wait.started", "audio.output.wait.completed"]
+      },
+      {
+        label: "Playback",
+        eventTypes: [
+          "audio.playback.started",
+          "audio.playback.stopped",
+          "audio.playback.ended"
+        ]
+      },
+      {
+        label: "Interruptions",
+        eventTypes: ["interruption.detected", "audio.playback.interrupted"]
+      },
+      { label: "Other" }
+    ];
+    const COLOR_BY_KEY = {
+      call: tintHex(BOSUN_COLORS.gray, 0.2),
+      vad: tintHex(BOSUN_COLORS.purple, 0.35),
+      stt: tintHex(BOSUN_COLORS.purple, 0.2),
+      trigger: BOSUN_COLORS.greenDark,
+      "reply.pending": tintHex(BOSUN_COLORS.greenDark, 0.18),
+      "llm.transport": tintHex(BOSUN_COLORS.blue, 0.18),
+      "llm.wait": tintHex(BOSUN_COLORS.blue, -0.25),
+      "llm.stream": BOSUN_COLORS.blue,
+      "tts.text": BOSUN_COLORS.orange,
+      "tts.provider.lifecycle": tintHex(BOSUN_COLORS.purple, -0.18),
+      "tts.provider": tintHex(BOSUN_COLORS.purple, 0.12),
+      "tts.decode": tintHex(BOSUN_COLORS.orange, -0.12),
+      "audio.output.wait": tintHex(BOSUN_COLORS.green, -0.1),
+      playback: tintHex(BOSUN_COLORS.greenDark, -0.08),
+      interruption: BOSUN_COLORS.red,
+      other: BOSUN_COLORS.gray
+    };
+    const SPAN_RULES = [
+      {
+        startEventType: "call.started",
+        endEventType: "call.ended",
+        row: "Call",
+        colorKey: "call",
+        label: "Call",
+        description: "Derived from adjacent call lifecycle events"
+      },
+      {
+        startEventType: "vad.activated",
+        endEventType: "vad.deactivated",
+        row: "VAD",
+        colorKey: "vad",
+        label: "VAD active",
+        description: "Derived from adjacent VAD activation and deactivation events"
+      },
+      {
+        startEventType: "reply.pending.started",
+        endEventType: "reply.pending.completed",
+        row: "Reply Pending",
+        colorKey: "reply.pending",
+        label: "Reply pending",
+        description: "Derived from adjacent reply-pending lifecycle events"
+      },
+      {
+        startEventType: "llm.connect_tcp.started",
+        endEventType: "llm.connect_tcp.completed",
+        row: "LLM Transport",
+        colorKey: "llm.transport",
+        label: "Connect TCP",
+        description: "Derived from adjacent TCP connect lifecycle events"
+      },
+      {
+        startEventType: "llm.start_tls.started",
+        endEventType: "llm.start_tls.completed",
+        row: "LLM Transport",
+        colorKey: "llm.transport",
+        label: "Start TLS",
+        description: "Derived from adjacent TLS lifecycle events"
+      },
+      {
+        startEventType: "llm.wait.started",
+        endEventType: "llm.wait.completed",
+        row: "LLM Wait",
+        colorKey: "llm.wait",
+        label: "LLM wait",
+        description: "Derived from adjacent LLM wait lifecycle events"
+      },
+      {
+        startEventType: "llm.stream.started",
+        endEventType: "llm.stream.completed",
+        row: "LLM Stream",
+        colorKey: "llm.stream",
+        label: "LLM stream",
+        description: "Derived from adjacent LLM stream lifecycle events"
+      },
+      {
+        startEventType: "tts.text.first_sent",
+        endEventType: "tts.text.completed",
+        row: "TTS Text",
+        colorKey: "tts.text",
+        label: "TTS text send",
+        description: "Derived from adjacent TTS text send and completion events"
+      },
+      {
+        startEventType: "tts.provider.started",
+        endEventType: "tts.audio.first_received",
+        row: "Provider",
+        colorKey: "tts.provider.lifecycle",
+        label: "Provider wait",
+        description: "Derived from adjacent provider start and first-audio events"
+      },
+      {
+        startEventType: "tts.audio.first_received",
+        endEventType: "tts.provider.completed",
+        row: "Provider",
+        colorKey: "tts.provider",
+        label: "Provider audio",
+        description: "Derived from adjacent provider first-audio and completion events"
+      },
+      {
+        startEventType: "tts.decode.started",
+        endEventType: "tts.decode.completed",
+        row: "Decode",
+        colorKey: "tts.decode",
+        label: "Decode",
+        description: "Derived from adjacent local decode lifecycle events"
+      },
+      {
+        startEventType: "audio.output.wait.started",
+        endEventType: "audio.output.wait.completed",
+        row: "Output Queue",
+        colorKey: "audio.output.wait",
+        label: "Output queue",
+        description: "Derived from adjacent audio-output wait lifecycle events"
+      },
+      {
+        startEventType: "audio.playback.started",
+        endEventType: "audio.playback.stopped",
+        row: "Playback",
+        colorKey: "playback",
+        label: "Playback",
+        description: "Derived from adjacent playback start and playback stop events"
+      }
+    ];
+    const SPAN_RULE_BY_START = new Map(SPAN_RULES.map((rule) => [rule.startEventType, rule]));
+    getPersistedTelescopeSourceId() ?? "";
+    let traces = [];
+    let recording = {
+      alignmentOffsetMs: 0
+    };
+    let uploadInFlight = false;
+    let playbackPositionMs = 0;
+    let playbackPlaying = false;
+    let viewportStartMs = null;
+    let viewportEndMs = null;
+    let fileInputEl = null;
+    let copyLatencyState = "idle";
+    let playbackAudioContext = null;
+    let playbackSourceNode = null;
+    let playbackStartedAtMs = null;
+    let playbackStartedAtContextTime = null;
+    const conversationId = derived(() => page.params.conversationId);
+    const timelineOriginMs = derived(() => {
+      let min = Number.POSITIVE_INFINITY;
+      for (const trace of traces) {
+        if (typeof trace.atMs !== "number" || !Number.isFinite(trace.atMs)) continue;
+        min = Math.min(min, trace.atMs);
+      }
+      if (Number.isFinite(min)) return min;
+      return Number.isFinite(min) ? min : 0;
+    });
+    const callSegments = derived(() => buildCallLatencySegments(traces));
+    const latencyTraceCount = derived(() => traces.length);
+    const timelineRows = derived(() => {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const segment of callSegments()) {
+        const items = grouped.get(segment.row);
+        if (items) items.push(segment);
+        else grouped.set(segment.row, [segment]);
+      }
+      return [...ROW_DEFS].reverse().map((row) => ({ label: row.label, segments: grouped.get(row.label) ?? [] })).filter((row) => row.segments.length > 0);
+    });
+    const guideLines = derived(() => buildGuideLines(timelineRows()));
+    const recordingStartMs = derived(() => {
+      return null;
+    });
+    const timelinePlotHeightPx = derived(() => TIMELINE_RULER_HEIGHT_PX + timelineRows().length * TIMELINE_ROW_HEIGHT_PX + WAVEFORM_ROW_HEIGHT_PX + TIMELINE_SCALE_HEIGHT_PX);
+    const playbackAbsoluteMs = derived(() => {
+      if (recordingStartMs() == null) return null;
+      return recordingStartMs() + playbackPositionMs;
+    });
+    const playbackCursor = derived(() => {
+      const absoluteMs = playbackAbsoluteMs();
+      if (absoluteMs == null || viewportStartMs == null || viewportEndMs == null) return null;
+      const durationMs = viewportEndMs - viewportStartMs;
+      if (!Number.isFinite(durationMs) || durationMs <= 0) return null;
+      if (absoluteMs < viewportStartMs || absoluteMs > viewportEndMs) return null;
+      return {
+        leftPercent: clamp((absoluteMs - viewportStartMs) / durationMs * 100, 0, 100),
+        heightPx: timelinePlotHeightPx()
+      };
+    });
+    const contentExtent = derived(() => {
+      let min = Number.POSITIVE_INFINITY;
+      let max = Number.NEGATIVE_INFINITY;
+      for (const segment of callSegments()) {
+        min = Math.min(min, segment.start);
+        max = Math.max(max, segment.end);
+      }
+      if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min) return null;
+      return { min, max };
+    });
+    const viewportDurationMs = derived(() => {
+      if (viewportStartMs == null || viewportEndMs == null) return null;
+      const duration = viewportEndMs - viewportStartMs;
+      return duration > 0 ? duration : null;
+    });
+    const visibleTicks = derived(() => {
+      if (viewportStartMs == null || viewportEndMs == null) return [];
+      return buildTicks(viewportStartMs, viewportEndMs, timelineOriginMs());
+    });
+    const visibleTickStepMs = derived(() => {
+      if (viewportStartMs == null || viewportEndMs == null) return null;
+      const durationMs = viewportEndMs - viewportStartMs;
+      if (!Number.isFinite(durationMs) || durationMs <= 0) return null;
+      return chooseTickStep(durationMs);
+    });
+    onDestroy(() => {
+      stopPlayback(false);
+      void closePlaybackAudioContext();
+    });
+    function normalizeNonEmptyString(value) {
+      if (typeof value !== "string") return null;
+      const trimmed = value.trim();
+      return trimmed ? trimmed : null;
+    }
+    function clampByte(value) {
+      return Math.max(0, Math.min(255, Math.round(value)));
+    }
+    function clamp(value, min, max) {
+      return Math.min(max, Math.max(min, value));
+    }
+    function tintHex(hex, amount) {
+      const raw = (hex ?? "").trim().replace(/^#/, "");
+      const expanded = raw.length === 3 ? raw.split("").map((part) => `${part}${part}`).join("") : raw;
+      if (expanded.length !== 6 || !/^[0-9a-fA-F]+$/.test(expanded)) return hex;
+      const r = parseInt(expanded.slice(0, 2), 16);
+      const g = parseInt(expanded.slice(2, 4), 16);
+      const b = parseInt(expanded.slice(4, 6), 16);
+      const t = Math.abs(Math.max(-1, Math.min(1, amount)));
+      const target = amount >= 0 ? 255 : 0;
+      return `#${clampByte(r + (target - r) * t).toString(16).padStart(2, "0")}${clampByte(g + (target - g) * t).toString(16).padStart(2, "0")}${clampByte(b + (target - b) * t).toString(16).padStart(2, "0")}`;
+    }
+    function fmtSignedMs(value) {
+      if (!Number.isFinite(value)) return "0 ms";
+      const rounded = Math.round(value);
+      if (rounded === 0) return "0 ms";
+      return `${rounded > 0 ? "+" : ""}${rounded} ms`;
+    }
+    function formatRelativeTime(offsetMs) {
+      if (!Number.isFinite(offsetMs)) return "—";
+      const sign = offsetMs < 0 ? "-" : "";
+      const abs = Math.abs(offsetMs);
+      if (abs < 1e4) return `${sign}${(abs / 1e3).toFixed(1)}s`;
+      if (abs < 6e4) return `${sign}${(abs / 1e3).toFixed(2)}s`;
+      const totalSeconds = abs / 1e3;
+      const minutes = Math.floor(totalSeconds / 60);
+      const seconds = totalSeconds - minutes * 60;
+      return `${sign}${minutes}:${seconds.toFixed(1).padStart(4, "0")}`;
+    }
+    function formatScaleStep(valueMs) {
+      if (valueMs == null || !Number.isFinite(valueMs) || valueMs <= 0) return "—";
+      if (valueMs < 1e3) return `${Math.round(valueMs)} ms`;
+      if (valueMs < 1e4) return `${Math.round(valueMs)} ms (${(valueMs / 1e3).toFixed(1)} s)`;
+      return `${Math.round(valueMs)} ms (${(valueMs / 1e3).toFixed(2)} s)`;
+    }
+    function safeJson(value) {
+      try {
+        return JSON.stringify(value ?? null, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    async function copyLatencyStream() {
+      try {
+        await navigator.clipboard.writeText(safeJson(traces));
+        copyLatencyState = "ok";
+        window.setTimeout(
+          () => {
+            copyLatencyState = "idle";
+          },
+          2e3
+        );
+      } catch (reason) {
+        console.error("Failed to copy latency stream", reason);
+        copyLatencyState = "error";
+        window.setTimeout(
+          () => {
+            copyLatencyState = "idle";
+          },
+          3e3
+        );
+      }
+    }
+    function describeTrace(trace) {
+      const time = typeof trace.createdAt === "number" && Number.isFinite(trace.createdAt) ? new Date(trace.createdAt).toLocaleTimeString() : "unknown time";
+      if (trace.traceType === "LATENCY") {
+        return `Latency • #${trace.seq ?? "?"} • ${trace.eventType ?? "unknown"} • ${time}`;
+      }
+      if (trace.traceType === "CONVERSATIONAL") {
+        return `Conversational • ${trace.eventName} • ${time}`;
+      }
+      if (trace.traceType === "STEP") {
+        return `Step • ${trace.name ?? "unknown"} • ${time}`;
+      }
+      return `API • ${trace.operationName} • ${time}`;
+    }
+    function latencyPayload(trace) {
+      const payload = trace.payload;
+      return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    }
+    function latencyRow(eventType) {
+      if (eventType === "call.started" || eventType === "call.ended") return "Call";
+      if (eventType.startsWith("vad.")) return "VAD";
+      if (eventType.startsWith("stt.")) return "STT";
+      if (eventType === "speech.created") return "Trigger";
+      if (eventType.startsWith("reply.pending.")) return "Reply Pending";
+      if (eventType.startsWith("llm.connect_tcp.") || eventType.startsWith("llm.start_tls.")) {
+        return "LLM Transport";
+      }
+      if (eventType === "llm.requested" || eventType.startsWith("llm.wait.")) return "LLM Wait";
+      if (eventType === "llm.first_token" || eventType === "llm.completed" || eventType.startsWith("llm.stream.")) {
+        return "LLM Stream";
+      }
+      if (eventType.startsWith("tts.text.")) return "TTS Text";
+      if (eventType.startsWith("tts.provider.")) return "Provider";
+      if (eventType === "tts.audio.first_received" || eventType === "tts.audio.last_received") {
+        return "Provider";
+      }
+      if (eventType.startsWith("tts.decode.")) return "Decode";
+      if (eventType.startsWith("audio.output.wait.")) return "Output Queue";
+      if (eventType === "interruption.detected" || eventType === "audio.playback.interrupted") {
+        return "Interruptions";
+      }
+      if (eventType.startsWith("audio.playback.")) return "Playback";
+      return "Other";
+    }
+    function latencyColorKey(eventType) {
+      if (eventType === "call.started" || eventType === "call.ended") return "call";
+      if (eventType.startsWith("vad.")) return "vad";
+      if (eventType.startsWith("stt.")) return "stt";
+      if (eventType === "speech.created") return "trigger";
+      if (eventType.startsWith("reply.pending.")) return "reply.pending";
+      if (eventType.startsWith("llm.connect_tcp.") || eventType.startsWith("llm.start_tls.")) {
+        return "llm.transport";
+      }
+      if (eventType === "llm.requested" || eventType.startsWith("llm.wait.")) return "llm.wait";
+      if (eventType === "llm.first_token" || eventType === "llm.completed" || eventType.startsWith("llm.stream.")) {
+        return "llm.stream";
+      }
+      if (eventType.startsWith("tts.text.")) return "tts.text";
+      if (eventType.startsWith("tts.provider.")) return "tts.provider.lifecycle";
+      if (eventType === "tts.audio.first_received" || eventType === "tts.audio.last_received") {
+        return "tts.provider";
+      }
+      if (eventType.startsWith("tts.decode.")) return "tts.decode";
+      if (eventType.startsWith("audio.output.wait.")) return "audio.output.wait";
+      if (eventType === "interruption.detected" || eventType === "audio.playback.interrupted") {
+        return "interruption";
+      }
+      if (eventType.startsWith("audio.playback.")) return "playback";
+      return "other";
+    }
+    function latencyLabel(trace) {
+      switch (trace.eventType) {
+        case "call.started":
+          return "Call started";
+        case "call.ended":
+          return "Call ended";
+        case "vad.activated":
+          return "VAD activated";
+        case "vad.deactivated":
+          return "VAD deactivated";
+        case "stt.started":
+          return "STT start";
+        case "stt.interim":
+          return "STT interim";
+        case "stt.final":
+          return "STT final";
+        case "speech.created":
+          return "Speech created";
+        case "reply.pending.started":
+          return "Reply pending start";
+        case "reply.pending.completed":
+          return "Reply pending end";
+        case "llm.connect_tcp.started":
+          return "Connect TCP start";
+        case "llm.connect_tcp.completed":
+          return "Connect TCP end";
+        case "llm.connect_tcp.failed":
+          return "Connect TCP failed";
+        case "llm.start_tls.started":
+          return "TLS start";
+        case "llm.start_tls.completed":
+          return "TLS end";
+        case "llm.start_tls.failed":
+          return "TLS failed";
+        case "llm.wait.started":
+          return "LLM wait start";
+        case "llm.wait.completed":
+          return "LLM wait end";
+        case "llm.stream.started":
+          return "LLM stream start";
+        case "llm.stream.completed":
+          return "LLM stream end";
+        case "llm.requested":
+          return "LLM request";
+        case "llm.first_token":
+          return "LLM first token";
+        case "llm.completed":
+          return "LLM end";
+        case "tts.text.first_sent":
+          return "TTS first text";
+        case "tts.text.completed":
+          return "TTS text end";
+        case "tts.provider.started":
+          return "Provider start";
+        case "tts.provider.completed":
+          return "Provider end";
+        case "tts.audio.first_received":
+          return "Provider audio received";
+        case "tts.audio.last_received":
+          return "Provider audio end";
+        case "tts.decode.started":
+          return "Decode start";
+        case "tts.decode.completed":
+          return "Decode end";
+        case "audio.output.wait.started":
+          return "Output queue start";
+        case "audio.output.wait.completed":
+          return "Output queue end";
+        case "interruption.detected":
+          return "Interruption detected";
+        case "audio.playback.started":
+          return "Playback start";
+        case "audio.playback.stopped":
+          return "Playback stop";
+        case "audio.playback.ended":
+          return "Playback end";
+        case "audio.playback.interrupted":
+          return "Playback interrupted";
+        default:
+          return trace.eventType;
+      }
+    }
+    function latencyDescription(trace) {
+      const payload = latencyPayload(trace);
+      switch (trace.eventType) {
+        case "call.started":
+          return "Call-scoped latency stream started";
+        case "call.ended":
+          return "Call-scoped latency stream ended";
+        case "vad.activated":
+          return "Raw VAD activation event";
+        case "vad.deactivated":
+          return "Raw VAD deactivation event";
+        case "stt.started":
+          return "Speech-to-text detected speech start";
+        case "stt.interim":
+          return normalizeNonEmptyString(payload.originalType) === "preflight_transcript" ? "Speech-to-text preflight transcript" : "Speech-to-text interim transcript";
+        case "stt.final":
+          return "Speech-to-text final transcript";
+        case "speech.created":
+          return "LiveKit created a speech handle";
+        case "reply.pending.started":
+          return "Reply generation was committed, but downstream generation has not started yet";
+        case "reply.pending.completed":
+          return "Reply generation moved from pending into the LLM request phase";
+        case "llm.connect_tcp.started":
+          return "httpcore started opening a new TCP connection for the LLM request";
+        case "llm.connect_tcp.completed":
+          return "httpcore finished opening a new TCP connection for the LLM request";
+        case "llm.connect_tcp.failed":
+          return "httpcore failed while opening a new TCP connection for the LLM request";
+        case "llm.start_tls.started":
+          return "httpcore started TLS negotiation for the LLM request";
+        case "llm.start_tls.completed":
+          return "httpcore finished TLS negotiation for the LLM request";
+        case "llm.start_tls.failed":
+          return "httpcore failed during TLS negotiation for the LLM request";
+        case "llm.wait.started":
+          return "LLM request is in flight and waiting for the first token";
+        case "llm.wait.completed":
+          return "The LLM wait phase ended when the first token arrived";
+        case "llm.stream.started":
+          return "LLM streaming phase started";
+        case "llm.stream.completed":
+          return "LLM streaming phase ended";
+        case "llm.requested":
+          return "AnyVan received an LLM request";
+        case "llm.first_token":
+          return "First LLM token received";
+        case "llm.completed":
+          return "LLM streaming completed";
+        case "tts.text.first_sent":
+          return "First text chunk sent to the TTS provider";
+        case "tts.text.completed":
+          return "Last non-empty text chunk observed for this TTS stream";
+        case "tts.provider.started":
+          return "Provider lifecycle started when the first non-empty TTS text chunk was sent";
+        case "tts.provider.completed":
+          return "Provider lifecycle ended when the provider stream reported completion";
+        case "tts.audio.first_received":
+          return "First audio chunk received from the TTS provider";
+        case "tts.audio.last_received":
+          return "Last audio chunk received from the TTS provider";
+        case "tts.decode.started":
+          return "First provider audio bytes were handed into the local decode path";
+        case "tts.decode.completed":
+          return "The first decoded audio frame left the local decode path";
+        case "audio.output.wait.started":
+          return "The first local audio frame was handed to the LiveKit audio output";
+        case "audio.output.wait.completed":
+          return "The audio-output wait phase ended when low-level playback actually started";
+        case "interruption.detected":
+          return "User speech overlapped active playback; this does not guarantee playback stopped";
+        case "audio.playback.started":
+          return "First played audio frame";
+        case "audio.playback.stopped":
+          return "Playback lifecycle ended on the Playback row";
+        case "audio.playback.ended":
+          return "Audio playback finished normally";
+        case "audio.playback.interrupted":
+          return "Audio playback ended because the output buffer was interrupted";
+        default:
+          return null;
+      }
+    }
+    function latencyText(trace) {
+      const payload = latencyPayload(trace);
+      return normalizeNonEmptyString(payload.text);
+    }
+    function makeSegment(input) {
+      return {
+        id: input.id,
+        row: input.row,
+        start: input.start,
+        end: input.end,
+        durationMs: Math.max(0, input.end - input.start),
+        colorKey: input.colorKey,
+        label: input.label,
+        description: input.description ?? null,
+        explain: input.explain ?? null,
+        text: input.text ?? null,
+        traceLabel: input.traceLabel
+      };
+    }
+    function compareLatencyTraces(a, b) {
+      return a.seq - b.seq || a.atMs - b.atMs || (a.createdAt ?? 0) - (b.createdAt ?? 0) || String(a.traceId ?? "").localeCompare(String(b.traceId ?? ""));
+    }
+    function findNextLatencyEvent(events, startIndex, match, stop) {
+      for (let index = startIndex + 1; index < events.length; index += 1) {
+        const next = events[index];
+        if (stop(next)) return null;
+        if (match(next)) return next;
+      }
+      return null;
+    }
+    function buildDerivedSegments(events) {
+      const built = [];
+      events.forEach((trace, index) => {
+        const rule = SPAN_RULE_BY_START.get(trace.eventType);
+        if (!rule) return;
+        const next = findNextLatencyEvent(events, index, (candidate) => candidate.eventType === rule.endEventType, (candidate) => candidate.eventType === rule.startEventType);
+        if (!next || next.atMs < trace.atMs) return;
+        built.push(makeSegment({
+          id: `derived:${rule.row.toLowerCase().replaceAll(" ", "_")}:${trace.seq}:${next.seq}`,
+          row: rule.row,
+          start: trace.atMs,
+          end: next.atMs,
+          colorKey: rule.colorKey,
+          label: rule.label,
+          description: rule.description,
+          traceLabel: describeTrace(trace)
+        }));
+      });
+      return built;
+    }
+    function buildCallLatencySegments(input) {
+      const events = input.slice().filter((trace) => typeof trace.atMs === "number" && Number.isFinite(trace.atMs) && typeof trace.seq === "number" && Number.isFinite(trace.seq)).sort(compareLatencyTraces);
+      const pointSegments = events.map((trace, index) => makeSegment({
+        id: `point:${trace.traceId ?? trace.seq}:${index}`,
+        row: latencyRow(trace.eventType),
+        start: trace.atMs,
+        end: trace.atMs,
+        colorKey: latencyColorKey(trace.eventType),
+        label: latencyLabel(trace),
+        description: latencyDescription(trace),
+        text: latencyText(trace),
+        traceLabel: describeTrace(trace)
+      }));
+      const derivedSegments = buildDerivedSegments(events);
+      return [...derivedSegments, ...pointSegments].sort((a, b) => a.start - b.start || (a.durationMs === 0 ? 1 : 0) - (b.durationMs === 0 ? 1 : 0) || a.end - b.end || a.row.localeCompare(b.row));
+    }
+    function segmentStyle(segment) {
+      if (viewportStartMs == null || viewportEndMs == null) return null;
+      const duration = viewportEndMs - viewportStartMs;
+      if (!Number.isFinite(duration) || duration <= 0) return null;
+      const fill = COLOR_BY_KEY[segment.colorKey] ?? BOSUN_COLORS.gray;
+      const border = tintHex(fill, -0.25);
+      if (segment.end === segment.start) {
+        if (segment.start < viewportStartMs || segment.start > viewportEndMs) return null;
+        const pointPercent = clamp((segment.start - viewportStartMs) / duration * 100, 0, 100);
+        return `left:calc(${pointPercent}% - 2px);width:4px;background:${fill};border-color:${border};`;
+      }
+      const visibleStart = Math.max(segment.start, viewportStartMs);
+      const visibleEnd = Math.min(segment.end, viewportEndMs);
+      if (visibleEnd < visibleStart) return null;
+      const leftPercent = (visibleStart - viewportStartMs) / duration * 100;
+      const widthPercent = (visibleEnd - visibleStart) / duration * 100;
+      return `left:${leftPercent}%;width:max(${widthPercent}%,2px);background:${fill};border-color:${border};`;
+    }
+    function guideLineStyle(guide) {
+      return `left:${guide.leftPercent}%;top:${guide.topPx}px;height:${guide.heightPx}px;border-color:${guide.color};opacity:${guide.opacity};`;
+    }
+    function buildGuideLines(rows) {
+      return [];
+    }
+    function chooseTickStep(durationMs) {
+      const approx = durationMs / 7;
+      const magnitude = 10 ** Math.floor(Math.log10(Math.max(1, approx)));
+      const normalized = approx / magnitude;
+      if (normalized <= 1) return 1 * magnitude;
+      if (normalized <= 2) return 2 * magnitude;
+      if (normalized <= 5) return 5 * magnitude;
+      return 10 * magnitude;
+    }
+    function buildTicks(startMs, endMs, originMs) {
+      const durationMs = endMs - startMs;
+      if (!Number.isFinite(durationMs) || durationMs <= 0) return [];
+      const stepMs = chooseTickStep(durationMs);
+      const firstTick = Math.ceil((startMs - originMs) / stepMs) * stepMs + originMs;
+      const ticks = [];
+      for (let tick = firstTick; tick <= endMs; tick += stepMs) {
+        const leftPercent = (tick - startMs) / durationMs * 100;
+        ticks.push({
+          time: tick,
+          leftPercent,
+          label: formatRelativeTime(tick - originMs)
+        });
+      }
+      return ticks;
+    }
+    async function closePlaybackAudioContext() {
+      const context = playbackAudioContext;
+      playbackAudioContext = null;
+      if (!context) return;
+      await context.close().catch(() => {
+      });
+    }
+    function getPlaybackPositionMs() {
+      const durationMs = getRecordingDurationMs();
+      if (playbackPlaying && playbackAudioContext && playbackStartedAtMs != null && playbackStartedAtContextTime != null) {
+        const elapsedMs = (playbackAudioContext.currentTime - playbackStartedAtContextTime) * 1e3;
+        const currentMs = playbackStartedAtMs + Math.max(0, elapsedMs);
+        return durationMs > 0 ? clamp(currentMs, 0, durationMs) : Math.max(0, currentMs);
+      }
+      return durationMs > 0 ? clamp(playbackPositionMs, 0, durationMs) : Math.max(0, playbackPositionMs);
+    }
+    function stopPlayback(preservePosition = true) {
+      if (preservePosition) {
+        playbackPositionMs = getPlaybackPositionMs();
+      }
+      const source = playbackSourceNode;
+      playbackSourceNode = null;
+      playbackStartedAtMs = null;
+      playbackStartedAtContextTime = null;
+      playbackPlaying = false;
+      if (!source) return;
+      source.onended = null;
+      try {
+        source.stop();
+      } catch {
+      }
+      source.disconnect();
+    }
+    function getRecordingDurationMs() {
+      return 0;
+    }
+    async function togglePlayback() {
+      return;
+    }
+    function fitViewport(markDirty = true) {
+      const extent = contentExtent();
+      if (!extent) return;
+      const paddingMs = Math.max(500, (extent.max - extent.min) * 0.05);
+      viewportStartMs = extent.min - paddingMs;
+      viewportEndMs = extent.max + paddingMs;
+    }
+    function clampViewport(startMs, endMs) {
+      const extent = contentExtent();
+      if (!extent) return { startMs, endMs };
+      const durationMs = endMs - startMs;
+      if (durationMs <= 0) return { startMs, endMs };
+      const marginMs = Math.max(1e3, durationMs * 0.25);
+      const minAllowed = extent.min - marginMs;
+      const maxAllowed = extent.max + marginMs;
+      if (durationMs >= maxAllowed - minAllowed) {
+        return { startMs: minAllowed, endMs: maxAllowed };
+      }
+      if (startMs < minAllowed) {
+        endMs += minAllowed - startMs;
+        startMs = minAllowed;
+      }
+      if (endMs > maxAllowed) {
+        startMs -= endMs - maxAllowed;
+        endMs = maxAllowed;
+      }
+      return { startMs, endMs };
+    }
+    function setViewport(startMs, endMs) {
+      if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs <= startMs) return;
+      const next = clampViewport(startMs, endMs);
+      viewportStartMs = next.startMs;
+      viewportEndMs = next.endMs;
+    }
+    function zoomViewport(factor, focusRatio = 0.5) {
+      if (viewportStartMs == null || viewportEndMs == null) return;
+      const currentDuration = viewportEndMs - viewportStartMs;
+      if (!Number.isFinite(currentDuration) || currentDuration <= 0) return;
+      const extent = contentExtent();
+      const contentDuration = extent ? extent.max - extent.min : currentDuration;
+      const minDuration = Math.min(100, currentDuration);
+      const maxDuration = Math.max(contentDuration + Math.max(2e3, contentDuration * 0.1), 5e3);
+      const nextDuration = clamp(currentDuration * factor, minDuration, maxDuration);
+      const nextFocusRatio = clamp(focusRatio, 0, 1);
+      const focusMs = viewportStartMs + currentDuration * nextFocusRatio;
+      const nextStartMs = focusMs - nextDuration * nextFocusRatio;
+      setViewport(nextStartMs, nextStartMs + nextDuration);
+    }
+    async function resetAlignment() {
+      return;
+    }
+    $$renderer2.push(`<div class="flex h-full min-h-0 flex-col bg-rc-gray-700"><div class="flex-none border-b border-rc-gray-300/40 p-4"><div class="flex flex-wrap items-start justify-between gap-3"><div><h2 class="text-lg font-semibold text-rc-gray-100">Latency `);
+    if (conversationId()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="text-rc-gray-100">for conversation Id:</span> <span class="text-rc-green-200">${escape_html(conversationId())}</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></h2> <div class="mt-2 flex flex-wrap gap-x-5 gap-y-1 text-xs text-rc-gray-300"><div><span class="text-rc-gray-400">Latency events:</span> <span class="font-mono text-rc-gray-100">${escape_html(latencyTraceCount())}</span></div> <div><span class="text-rc-gray-400">Timeline items:</span> <span class="font-mono text-rc-gray-100">${escape_html(callSegments().length)}</span></div> <div><span class="text-rc-gray-400">Recording offset:</span> <span class="font-mono text-rc-gray-100">${escape_html(fmtSignedMs(recording.alignmentOffsetMs))}</span></div> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (viewportStartMs != null && viewportEndMs != null) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div><span class="text-rc-gray-400">Viewport:</span> <span class="font-mono text-rc-gray-100">${escape_html(formatRelativeTime(viewportStartMs - timelineOriginMs()))} → ${escape_html(formatRelativeTime(viewportEndMs - timelineOriginMs()))}</span></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div></div> <div class="flex flex-wrap items-center gap-2"><input type="file" accept=".wav,audio/wav,audio/x-wav" class="hidden"/> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: uploadInFlight,
+      onclick: () => fileInputEl?.click(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->${escape_html("Upload WAV")}`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: true,
+      onclick: () => void togglePlayback(),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->${escape_html(playbackPlaying ? "Pause" : "Play")}`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: viewportDurationMs() == null,
+      onclick: () => zoomViewport(0.8),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Zoom in`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: viewportDurationMs() == null,
+      onclick: () => zoomViewport(1.25),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Zoom out`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: !contentExtent(),
+      onclick: () => fitViewport(true),
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Fit call`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: true,
+      onclick: resetAlignment,
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->Reset alignment`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----> `);
+    Button($$renderer2, {
+      variant: "secondary",
+      size: "small",
+      disabled: !traces.length,
+      onclick: copyLatencyStream,
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->${escape_html(copyLatencyState === "ok" ? "Copied" : copyLatencyState === "error" ? "Copy failed" : "Copy latency stream")}`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----></div></div> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div> <div class="rc-scroll min-h-0 flex-1 overflow-auto p-4"><div class="flex flex-col gap-4"><div class="rounded-md border border-rc-gray-650 bg-rc-gray-900/60 p-3"><div class="flex flex-wrap items-start justify-between gap-3"><div><div class="text-sm font-semibold text-rc-gray-100">Recording</div> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<div class="mt-1 text-sm text-rc-gray-300">Upload a WAV recording to overlay the call waveform and persist it under this
+								project's \`data/\` folder.</div>`);
+    }
+    $$renderer2.push(`<!--]--></div> <div class="text-xs text-rc-gray-300"><div>Drag the latency chart to pan the viewport.</div> <div>Scroll anywhere in the timeline to zoom traces and waveform together.</div> <div>Click the waveform to move the playhead.</div> <div>Press Space to play or pause.</div> <div>Drag the waveform itself to align the audio against the traces.</div> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div></div></div> <div class="rounded-md border border-rc-gray-650 bg-rc-gray-900/60 p-3"><div class="mb-3 flex items-center justify-between gap-3"><div class="text-sm font-semibold text-rc-gray-100">Call timeline</div> <div class="text-xs text-rc-gray-400">Shared x-axis for traces and waveform</div></div> `);
+    if (!callSegments().length) {
+      $$renderer2.push("<!--[1-->");
+      $$renderer2.push(`<div class="text-sm text-rc-gray-300">No latency events were found on this call.</div>`);
+    } else if (viewportStartMs == null || viewportEndMs == null) {
+      $$renderer2.push("<!--[2-->");
+      $$renderer2.push(`<div class="text-sm text-rc-gray-300">Preparing timeline…</div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<div class="grid grid-cols-[140px_minmax(0,1fr)] gap-x-3"><div class="flex flex-col"><div class="h-8"></div> <!--[-->`);
+      const each_array = ensure_array_like(timelineRows());
+      for (let $$index = 0, $$length = each_array.length; $$index < $$length; $$index++) {
+        let row = each_array[$$index];
+        $$renderer2.push(`<div class="flex h-10 items-center text-xs text-rc-gray-300">${escape_html(row.label)}</div>`);
+      }
+      $$renderer2.push(`<!--]--> <div class="flex h-40 items-center text-xs text-rc-gray-300">Waveform</div> <div class="flex h-8 items-center text-xs text-rc-gray-300">Scale</div></div> <div class="relative"><div class="pointer-events-none absolute inset-0 z-10 overflow-hidden"><!--[-->`);
+      const each_array_1 = ensure_array_like(guideLines());
+      for (let $$index_1 = 0, $$length = each_array_1.length; $$index_1 < $$length; $$index_1++) {
+        let guide = each_array_1[$$index_1];
+        $$renderer2.push(`<div class="absolute -translate-x-1/2 border-l border-dashed"${attr_style(guideLineStyle(guide))}></div>`);
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (playbackCursor()) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="absolute top-0 -translate-x-1/2 border-l-2 border-rc-green-200/90"${attr_style(`left:${playbackCursor().leftPercent}%;height:${playbackCursor().heightPx}px;`)}></div> <div class="absolute top-1 h-2 w-2 -translate-x-1/2 rounded-full bg-rc-green-200"${attr_style(`left:${playbackCursor().leftPercent}%;`)}></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div> <div class="relative z-0 h-8 overflow-hidden rounded-t border border-b-0 border-rc-gray-700/60 bg-rc-gray-800/30"><!--[-->`);
+      const each_array_2 = ensure_array_like(visibleTicks());
+      for (let $$index_2 = 0, $$length = each_array_2.length; $$index_2 < $$length; $$index_2++) {
+        let tick = each_array_2[$$index_2];
+        $$renderer2.push(`<div class="absolute inset-y-0 w-px bg-rc-gray-700/70"${attr_style(`left:${tick.leftPercent}%;`)}></div> <div class="absolute bottom-1 -translate-x-1/2 whitespace-nowrap text-[11px] text-rc-gray-400"${attr_style(`left:${tick.leftPercent}%;`)}>${escape_html(tick.label)}</div>`);
+      }
+      $$renderer2.push(`<!--]--></div> <!--[-->`);
+      const each_array_3 = ensure_array_like(timelineRows());
+      for (let $$index_5 = 0, $$length = each_array_3.length; $$index_5 < $$length; $$index_5++) {
+        let row = each_array_3[$$index_5];
+        $$renderer2.push(`<div class="relative z-0 h-10 overflow-hidden border-x border-t border-rc-gray-700/60 bg-rc-gray-800/20"><!--[-->`);
+        const each_array_4 = ensure_array_like(visibleTicks());
+        for (let $$index_3 = 0, $$length2 = each_array_4.length; $$index_3 < $$length2; $$index_3++) {
+          let tick = each_array_4[$$index_3];
+          $$renderer2.push(`<div class="absolute inset-y-0 w-px bg-rc-gray-700/60"${attr_style(`left:${tick.leftPercent}%;`)}></div>`);
+        }
+        $$renderer2.push(`<!--]--> <!--[-->`);
+        const each_array_5 = ensure_array_like(row.segments);
+        for (let $$index_4 = 0, $$length2 = each_array_5.length; $$index_4 < $$length2; $$index_4++) {
+          let segment = each_array_5[$$index_4];
+          const style = segmentStyle(segment);
+          if (style) {
+            $$renderer2.push("<!--[0-->");
+            $$renderer2.push(`<div class="absolute top-1/2 h-5 -translate-y-1/2 rounded border shadow-[0_0_0_1px_rgba(0,0,0,0.12)]"${attr_style(style)}></div>`);
+          } else {
+            $$renderer2.push("<!--[-1-->");
+          }
+          $$renderer2.push(`<!--]-->`);
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      }
+      $$renderer2.push(`<!--]--> <div class="relative z-0 h-40 overflow-hidden border-x border-t border-rc-gray-700/60 bg-rc-gray-800/30">`);
+      {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="absolute inset-0 flex items-center justify-center px-4 text-sm text-rc-gray-300">Upload a WAV file to render the call waveform here.</div>`);
+      }
+      $$renderer2.push(`<!--]--> <!--[-->`);
+      const each_array_6 = ensure_array_like(visibleTicks());
+      for (let $$index_6 = 0, $$length = each_array_6.length; $$index_6 < $$length; $$index_6++) {
+        let tick = each_array_6[$$index_6];
+        $$renderer2.push(`<div class="absolute inset-y-0 w-px bg-rc-gray-700/60"${attr_style(`left:${tick.leftPercent}%;`)}></div>`);
+      }
+      $$renderer2.push(`<!--]--> `);
+      {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div> <div class="relative z-0 h-8 overflow-hidden rounded-b border-x border-b border-t border-rc-gray-700/60 bg-rc-gray-800/25"><div class="absolute left-3 top-1/2 -translate-y-1/2 rounded bg-rc-gray-900/80 px-2 py-0.5 text-[11px] text-rc-gray-300">Grid: ${escape_html(formatScaleStep(visibleTickStepMs()))}</div> <!--[-->`);
+      const each_array_7 = ensure_array_like(visibleTicks());
+      for (let $$index_7 = 0, $$length = each_array_7.length; $$index_7 < $$length; $$index_7++) {
+        let tick = each_array_7[$$index_7];
+        $$renderer2.push(`<div class="absolute inset-y-0 w-px bg-rc-gray-700/60"${attr_style(`left:${tick.leftPercent}%;`)}></div> <div class="absolute bottom-1 -translate-x-1/2 whitespace-nowrap text-[11px] text-rc-gray-400"${attr_style(`left:${tick.leftPercent}%;`)}>${escape_html(tick.label)}</div>`);
+      }
+      $$renderer2.push(`<!--]--></div></div></div>`);
+    }
+    $$renderer2.push(`<!--]--></div></div></div></div> `);
+    {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]-->`);
+  });
+}
+
+export { _page as default };
+//# sourceMappingURL=_page.svelte-BhU1G2ip.js.map