browser-pilot 0.0.14 → 0.0.16

package/dist/{chunk-7NDR6V7S.mjs → chunk-6GBYX7C2.mjs}

@@ -1,226 +1,7 @@
 import {
   CDPError,
-  createCDPClient,
   stringifyUnknown
-} from "./chunk-SPSZZH22.mjs";
-
-// src/providers/browserbase.ts
-var BrowserBaseProvider = class {
-  name = "browserbase";
-  apiKey;
-  projectId;
-  baseUrl;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.projectId = options.projectId;
-    this.baseUrl = options.baseUrl ?? "https://api.browserbase.com";
-  }
-  async createSession(options = {}) {
-    const response = await fetch(`${this.baseUrl}/v1/sessions`, {
-      method: "POST",
-      headers: {
-        "X-BB-API-Key": this.apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        projectId: this.projectId,
-        browserSettings: {
-          viewport: options.width && options.height ? {
-            width: options.width,
-            height: options.height
-          } : void 0
-        },
-        ...options
-      })
-    });
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`BrowserBase createSession failed: ${response.status} ${text}`);
-    }
-    const session = await response.json();
-    const connectResponse = await fetch(`${this.baseUrl}/v1/sessions/${session.id}`, {
-      headers: {
-        "X-BB-API-Key": this.apiKey
-      }
-    });
-    if (!connectResponse.ok) {
-      throw new Error(`BrowserBase getSession failed: ${connectResponse.status}`);
-    }
-    const sessionDetails = await connectResponse.json();
-    if (!sessionDetails.connectUrl) {
-      throw new Error("BrowserBase session does not have a connectUrl");
-    }
-    return {
-      wsUrl: sessionDetails.connectUrl,
-      sessionId: session.id,
-      metadata: {
-        debugUrl: sessionDetails.debugUrl,
-        projectId: this.projectId,
-        status: sessionDetails.status
-      },
-      close: async () => {
-        await fetch(`${this.baseUrl}/v1/sessions/${session.id}`, {
-          method: "DELETE",
-          headers: {
-            "X-BB-API-Key": this.apiKey
-          }
-        });
-      }
-    };
-  }
-  async resumeSession(sessionId) {
-    const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
-      headers: {
-        "X-BB-API-Key": this.apiKey
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`BrowserBase resumeSession failed: ${response.status}`);
-    }
-    const session = await response.json();
-    if (!session.connectUrl) {
-      throw new Error("BrowserBase session does not have a connectUrl (may be closed)");
-    }
-    return {
-      wsUrl: session.connectUrl,
-      sessionId: session.id,
-      metadata: {
-        debugUrl: session.debugUrl,
-        projectId: this.projectId,
-        status: session.status
-      },
-      close: async () => {
-        await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
-          method: "DELETE",
-          headers: {
-            "X-BB-API-Key": this.apiKey
-          }
-        });
-      }
-    };
-  }
-};
-
-// src/providers/browserless.ts
-var BrowserlessProvider = class {
-  name = "browserless";
-  token;
-  baseUrl;
-  constructor(options) {
-    this.token = options.token;
-    this.baseUrl = options.baseUrl ?? "wss://chrome.browserless.io";
-  }
-  async createSession(options = {}) {
-    const params = new URLSearchParams({
-      token: this.token
-    });
-    if (options.width && options.height) {
-      params.set("--window-size", `${options.width},${options.height}`);
-    }
-    if (options.proxy?.server) {
-      params.set("--proxy-server", options.proxy.server);
-    }
-    const wsUrl = `${this.baseUrl}?${params.toString()}`;
-    return {
-      wsUrl,
-      metadata: {
-        provider: "browserless"
-      },
-      close: async () => {
-      }
-    };
-  }
-  // Browserless doesn't support session resumption in the same way
-  // Each connection is a fresh browser instance
-};
-
-// src/providers/generic.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function fetchDevToolsJson(host, path, errorPrefix, options = {}) {
-  const protocol = host.includes("://") ? "" : "http://";
-  const attempts = options.attempts ?? 1;
-  let delayMs = options.initialDelayMs ?? 50;
-  const maxDelayMs = options.maxDelayMs ?? 250;
-  let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt++) {
-    try {
-      const response = await fetch(`${protocol}${host}${path}`);
-      if (response.ok) {
-        return await response.json();
-      }
-      lastError = new Error(`${errorPrefix}: ${response.status}`);
-    } catch (error) {
-      lastError = new Error(
-        `${errorPrefix}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    if (attempt < attempts) {
-      await sleep(delayMs);
-      delayMs = Math.min(delayMs * 2, maxDelayMs);
-    }
-  }
-  throw lastError ?? new Error(errorPrefix);
-}
-var GenericProvider = class {
-  name = "generic";
-  wsUrl;
-  constructor(options) {
-    this.wsUrl = options.wsUrl;
-  }
-  async createSession(_options = {}) {
-    return {
-      wsUrl: this.wsUrl,
-      metadata: {
-        provider: "generic"
-      },
-      close: async () => {
-      }
-    };
-  }
-};
-async function getBrowserWebSocketUrl(host = "localhost:9222") {
-  const info = await fetchDevToolsJson(host, "/json/version", "Failed to get browser info", {
-    attempts: 10,
-    initialDelayMs: 50,
-    maxDelayMs: 250
-  });
-  return info.webSocketDebuggerUrl;
-}
-
-// src/providers/index.ts
-function createProvider(options) {
-  switch (options.provider) {
-    case "browserbase":
-      if (!options.apiKey) {
-        throw new Error("BrowserBase provider requires apiKey");
-      }
-      if (!options.projectId) {
-        throw new Error("BrowserBase provider requires projectId");
-      }
-      return new BrowserBaseProvider({
-        apiKey: options.apiKey,
-        projectId: options.projectId
-      });
-    case "browserless":
-      if (!options.apiKey) {
-        throw new Error("Browserless provider requires apiKey (token)");
-      }
-      return new BrowserlessProvider({
-        token: options.apiKey
-      });
-    case "generic":
-      if (!options.wsUrl) {
-        throw new Error("Generic provider requires wsUrl");
-      }
-      return new GenericProvider({
-        wsUrl: options.wsUrl
-      });
-    default:
-      throw new Error(`Unknown provider: ${options.provider}`);
-  }
-}
+} from "./chunk-DTVRFXKI.mjs";
 
 // src/actions/executor.ts
 import * as fs from "fs";
@@ -693,7 +474,7 @@ var CHECK_EDITABLE = `function() {
 
   return { actionable: true };
 }`;
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 var BACKOFF = [0, 20, 100, 100];
@@ -777,7 +558,7 @@ async function ensureActionable(cdp, objectId, checks, options) {
       );
     }
     const delay = attempt < BACKOFF.length ? BACKOFF[attempt] ?? 0 : 500;
-    if (delay > 0) await sleep2(delay);
+    if (delay > 0) await sleep(delay);
     attempt++;
   }
 }
@@ -1056,17 +837,978 @@ var NavigationError = class extends Error {
     super(message);
     this.name = "NavigationError";
   }
-};
-
-// src/actions/executor.ts
-var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_RECORDING_SKIP_ACTIONS = [
-  "wait",
-  "snapshot",
-  "forms",
-  "text",
-  "screenshot"
-];
+};
+
+// src/trace/views.ts
+function takeRecent(events, limit = 5) {
+  return events.slice(-limit).map((event) => ({
+    ts: event.ts,
+    event: event.event,
+    summary: event.summary,
+    severity: event.severity,
+    url: event.url
+  }));
+}
+function buildTraceSummary(events, view) {
+  switch (view) {
+    case "ws":
+      return summarizeWs(events);
+    case "voice":
+      return summarizeVoice(events);
+    case "console":
+      return summarizeConsole(events);
+    case "permissions":
+      return summarizePermissions(events);
+    case "media":
+      return summarizeMedia(events);
+    case "ui":
+      return summarizeUi(events);
+    case "session":
+      return summarizeSession(events);
+  }
+  throw new Error(`Unsupported trace view: ${view}`);
+}
+function buildTraceSummaries(events) {
+  return {
+    ws: summarizeWs(events),
+    voice: summarizeVoice(events),
+    console: summarizeConsole(events),
+    permissions: summarizePermissions(events),
+    media: summarizeMedia(events),
+    ui: summarizeUi(events),
+    session: summarizeSession(events)
+  };
+}
+function summarizeWs(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "ws" || event.event.startsWith("ws.")
+  );
+  const connections = /* @__PURE__ */ new Map();
+  for (const event of relevant) {
+    const id = event.connectionId ?? event.requestId ?? event.traceId;
+    let connection = connections.get(id);
+    if (!connection) {
+      connection = { id, sent: 0, received: 0, lastMessages: [] };
+      connections.set(id, connection);
+    }
+    connection.url = event.url ?? connection.url;
+    if (event.event === "ws.connection.created") {
+      connection.createdAt = event.ts;
+    }
+    if (event.event === "ws.connection.closed") {
+      connection.closedAt = event.ts;
+    }
+    if (event.event === "ws.frame.sent") {
+      connection.sent += 1;
+      const payload = typeof event.data["payload"] === "string" ? event.data["payload"] : "";
+      if (payload) connection.lastMessages.push(`sent: ${payload}`);
+    }
+    if (event.event === "ws.frame.received") {
+      connection.received += 1;
+      const payload = typeof event.data["payload"] === "string" ? event.data["payload"] : "";
+      if (payload) connection.lastMessages.push(`recv: ${payload}`);
+    }
+    connection.lastMessages = connection.lastMessages.slice(-3);
+  }
+  const values = [...connections.values()];
+  const reconnects = values.reduce((count, connection) => {
+    return connection.closedAt && !connection.createdAt ? count + 1 : count;
+  }, 0);
+  return {
+    view: "ws",
+    totalEvents: relevant.length,
+    connections: values.map((connection) => ({
+      id: connection.id,
+      url: connection.url ?? null,
+      createdAt: connection.createdAt ?? null,
+      closedAt: connection.closedAt ?? null,
+      sent: connection.sent,
+      received: connection.received,
+      lastMessages: connection.lastMessages,
+      connectedButSilent: !!connection.createdAt && !connection.closedAt && connection.sent + connection.received === 0
+    })),
+    reconnects,
+    recent: takeRecent(relevant)
+  };
+}
+function summarizeConsole(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "console" || event.event.startsWith("console.") || event.event === "runtime.exception" || event.event === "runtime.unhandledRejection"
+  );
+  return {
+    view: "console",
+    errors: relevant.filter(
+      (event) => event.event === "console.error" || event.event === "runtime.exception" || event.event === "runtime.unhandledRejection"
+    ).length,
+    warnings: relevant.filter((event) => event.event === "console.warn").length,
+    logs: relevant.filter((event) => event.event === "console.log").length,
+    recent: takeRecent(relevant)
+  };
+}
+function summarizePermissions(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "permission" || event.event.startsWith("permission.")
+  );
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of relevant) {
+    const name = typeof event.data["name"] === "string" ? event.data["name"] : null;
+    const state = typeof event.data["state"] === "string" ? event.data["state"] : null;
+    if (name && state) {
+      latest.set(name, state);
+    }
+  }
+  return {
+    view: "permissions",
+    states: Object.fromEntries(latest),
+    changes: relevant.filter((event) => event.event === "permission.changed").length,
+    recent: takeRecent(relevant)
+  };
+}
+function summarizeMedia(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "media" || event.event.startsWith("media.")
+  );
+  const liveTracks = /* @__PURE__ */ new Map();
+  for (const event of relevant) {
+    const label = typeof event.data["label"] === "string" ? event.data["label"] : "";
+    const kind = typeof event.data["kind"] === "string" ? event.data["kind"] : "";
+    const key = `${kind}:${label}`;
+    if (event.event === "media.track.started") {
+      liveTracks.set(key, kind);
+    }
+    if (event.event === "media.track.ended") {
+      liveTracks.delete(key);
+    }
+  }
+  return {
+    view: "media",
+    tracksStarted: relevant.filter((event) => event.event === "media.track.started").length,
+    tracksEnded: relevant.filter((event) => event.event === "media.track.ended").length,
+    playbackStarted: relevant.filter((event) => event.event === "media.playback.started").length,
+    playbackStopped: relevant.filter((event) => event.event === "media.playback.stopped").length,
+    liveTracks: [...liveTracks.values()],
+    recent: takeRecent(relevant)
+  };
+}
+function summarizeVoice(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "voice" || event.event.startsWith("voice.")
+  );
+  return {
+    view: "voice",
+    ready: relevant.filter((event) => event.event === "voice.pipeline.ready").length,
+    notReady: relevant.filter((event) => event.event === "voice.pipeline.notReady").length,
+    captureStarted: relevant.filter((event) => event.event === "voice.capture.started").length,
+    captureStopped: relevant.filter((event) => event.event === "voice.capture.stopped").length,
+    detectedAudio: relevant.filter((event) => event.event === "voice.capture.detectedAudio").length,
+    recent: takeRecent(relevant)
+  };
+}
+function summarizeUi(events) {
+  const relevant = events.filter(
+    (event) => event.channel === "dom" || event.event.startsWith("dom.") || event.channel === "action"
+  );
+  return {
+    view: "ui",
+    actions: relevant.filter((event) => event.channel === "action").length,
+    domChanges: relevant.filter((event) => event.channel === "dom").length,
+    recent: takeRecent(relevant)
+  };
+}
+function summarizeSession(events) {
+  const byChannel = /* @__PURE__ */ new Map();
+  const failedActions = events.filter((event) => event.event === "action.failed").length;
+  for (const event of events) {
+    byChannel.set(event.channel, (byChannel.get(event.channel) ?? 0) + 1);
+  }
+  return {
+    view: "session",
+    totalEvents: events.length,
+    byChannel: Object.fromEntries(byChannel),
+    failedActions,
+    recent: takeRecent(events)
+  };
+}
+
+// src/recording/manifest.ts
+function isCanonicalRecordingManifest(value) {
+  return Boolean(
+    value && typeof value === "object" && value.version === 2 && typeof value.session === "object"
+  );
+}
+function isLegacyRecordingManifest(value) {
+  return Boolean(
+    value && typeof value === "object" && value.version === 1 && Array.isArray(value.frames)
+  );
+}
+function createRecordingManifest(input) {
+  const actions = input.frames.map((frame) => {
+    const actionId = frame.actionId ?? `action-${frame.seq}`;
+    return {
+      id: actionId,
+      stepIndex: frame.stepIndex ?? Math.max(0, frame.seq - 1),
+      action: frame.action,
+      selector: frame.selector,
+      selectorUsed: frame.selectorUsed ?? frame.selector,
+      value: frame.value,
+      url: frame.url,
+      success: frame.success,
+      durationMs: frame.durationMs,
+      error: frame.error,
+      ts: new Date(frame.timestamp).toISOString(),
+      pageUrl: frame.pageUrl,
+      pageTitle: frame.pageTitle,
+      coordinates: frame.coordinates,
+      boundingBox: frame.boundingBox
+    };
+  });
+  const screenshots = input.frames.map((frame) => ({
+    id: `shot-${frame.seq}`,
+    stepIndex: frame.stepIndex ?? Math.max(0, frame.seq - 1),
+    actionId: frame.actionId ?? `action-${frame.seq}`,
+    file: frame.screenshot,
+    ts: new Date(frame.timestamp).toISOString(),
+    success: frame.success,
+    pageUrl: frame.pageUrl,
+    pageTitle: frame.pageTitle,
+    coordinates: frame.coordinates,
+    boundingBox: frame.boundingBox
+  }));
+  return {
+    version: 2,
+    recordedAt: input.recordedAt,
+    session: {
+      id: input.sessionId,
+      startUrl: input.startUrl,
+      endUrl: input.endUrl,
+      targetId: input.targetId,
+      profile: input.profile
+    },
+    recipe: {
+      steps: input.steps
+    },
+    actions,
+    screenshots,
+    trace: {
+      events: input.traceEvents,
+      summaries: buildTraceSummaries(input.traceEvents)
+    },
+    assertions: input.assertions ?? [],
+    notes: input.notes ?? [],
+    artifacts: {
+      recordingManifest: input.recordingManifest ?? "recording.json",
+      screenshotDir: input.screenshotDir ?? "screenshots/"
+    }
+  };
+}
+function canonicalizeRecordingArtifact(value) {
+  if (isCanonicalRecordingManifest(value)) {
+    return value;
+  }
+  if (!isLegacyRecordingManifest(value)) {
+    throw new Error("Unsupported recording artifact");
+  }
+  const traceEvents = buildTraceEventsFromLegacy(value);
+  const steps = value.frames.map((frame) => frameToStep(frame));
+  return createRecordingManifest({
+    recordedAt: value.recordedAt,
+    sessionId: value.sessionId,
+    startUrl: value.startUrl,
+    endUrl: value.endUrl,
+    steps,
+    frames: value.frames,
+    traceEvents,
+    notes: ["Converted from legacy recording manifest"]
+  });
+}
+function buildTraceEventsFromLegacy(value) {
+  const events = [];
+  for (const frame of value.frames) {
+    events.push({
+      traceId: frame.actionId ?? `legacy-${frame.seq}`,
+      sessionId: value.sessionId,
+      ts: new Date(frame.timestamp).toISOString(),
+      elapsedMs: frame.timestamp - new Date(value.recordedAt).getTime(),
+      channel: "action",
+      event: frame.success ? "action.succeeded" : "action.failed",
+      severity: frame.success ? "info" : "error",
+      summary: `${frame.action}${frame.selector ? ` ${frame.selector}` : ""}`,
+      data: {
+        action: frame.action,
+        selector: frame.selector,
+        value: frame.value ?? null,
+        pageUrl: frame.pageUrl ?? null,
+        pageTitle: frame.pageTitle ?? null,
+        screenshot: frame.screenshot
+      },
+      actionId: frame.actionId ?? `action-${frame.seq}`,
+      stepIndex: frame.stepIndex ?? Math.max(0, frame.seq - 1),
+      selector: frame.selector,
+      selectorUsed: frame.selectorUsed ?? frame.selector,
+      url: frame.pageUrl ?? frame.url
+    });
+  }
+  return events;
+}
+function frameToStep(frame) {
+  switch (frame.action) {
+    case "fill":
+      return { action: "fill", selector: frame.selector, value: frame.value };
+    case "submit":
+      return { action: "submit", selector: frame.selector };
+    case "goto":
+      return { action: "goto", url: frame.url ?? frame.pageUrl };
+    case "press":
+      return { action: "press", key: frame.value ?? "Enter" };
+    default:
+      return { action: "click", selector: frame.selector };
+  }
+}
+
+// src/trace/model.ts
+function createTraceId(prefix = "evt") {
+  const random = Math.random().toString(36).slice(2, 10);
+  return `${prefix}-${Date.now().toString(36)}-${random}`;
+}
+function normalizeTraceEvent(event) {
+  return {
+    traceId: event.traceId ?? createTraceId(event.channel),
+    ts: event.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    elapsedMs: event.elapsedMs ?? 0,
+    severity: event.severity ?? inferSeverity(event.event),
+    data: event.data ?? {},
+    ...event
+  };
+}
+function inferSeverity(eventName) {
+  if (eventName.includes(".failed") || eventName.includes(".error") || eventName.includes("exception") || eventName.includes("notReady")) {
+    return "error";
+  }
+  if (eventName.includes(".closed") || eventName.includes(".warn") || eventName.includes(".changed")) {
+    return "warn";
+  }
+  return "info";
+}
+
+// src/trace/script.ts
+var TRACE_BINDING_NAME = "__bpTraceBinding";
+var TRACE_SCRIPT = `
+(() => {
+  if (window.__bpTraceInstalled) return;
+  window.__bpTraceInstalled = true;
+
+  const binding = globalThis.${TRACE_BINDING_NAME};
+  if (typeof binding !== 'function') return;
+
+  const emit = (event, data = {}, severity = 'info', summary) => {
+    try {
+      globalThis.__bpTraceRecentEvents = globalThis.__bpTraceRecentEvents || [];
+      const payload = {
+        event,
+        severity,
+        summary: summary || event,
+        ts: Date.now(),
+        data,
+      };
+      globalThis.__bpTraceRecentEvents.push(payload);
+      if (globalThis.__bpTraceRecentEvents.length > 200) {
+        globalThis.__bpTraceRecentEvents.splice(0, globalThis.__bpTraceRecentEvents.length - 200);
+      }
+      binding(JSON.stringify(payload));
+    } catch {}
+  };
+
+  const patchWebSocket = () => {
+    const NativeWebSocket = window.WebSocket;
+    if (typeof NativeWebSocket !== 'function' || window.__bpTraceWebSocketInstalled) return;
+    window.__bpTraceWebSocketInstalled = true;
+
+    const nextId = () => Math.random().toString(36).slice(2, 10);
+
+    const patchInstance = (socket, urlValue) => {
+      if (!socket || socket.__bpTracePatched) return socket;
+      socket.__bpTracePatched = true;
+      socket.__bpTraceId = socket.__bpTraceId || nextId();
+      socket.__bpTraceUrl = String(urlValue || socket.url || '');
+      globalThis.__bpTrackedWebSockets = globalThis.__bpTrackedWebSockets || new Set();
+      globalThis.__bpTrackedWebSockets.add(socket);
+
+      emit(
+        'ws.connection.created',
+        { connectionId: socket.__bpTraceId, url: socket.__bpTraceUrl },
+        'info',
+        'WebSocket opened ' + socket.__bpTraceUrl
+      );
+
+      const originalSend = socket.send;
+      socket.send = function(data) {
+        const payload =
+          typeof data === 'string'
+            ? data
+            : data && typeof data.toString === 'function'
+              ? data.toString()
+              : '[binary]';
+        emit(
+          'ws.frame.sent',
+          {
+            connectionId: socket.__bpTraceId,
+            url: socket.__bpTraceUrl,
+            payload,
+            length: payload.length,
+          },
+          'info',
+          'WebSocket frame sent'
+        );
+        return originalSend.call(this, data);
+      };
+
+      socket.addEventListener('message', (event) => {
+        if (socket.__bpOfflineNotified || socket.__bpTraceClosed) {
+          return;
+        }
+        const data = event && 'data' in event ? event.data : '';
+        const payload =
+          typeof data === 'string'
+            ? data
+            : data && typeof data.toString === 'function'
+              ? data.toString()
+              : '[binary]';
+        emit(
+          'ws.frame.received',
+          {
+            connectionId: socket.__bpTraceId,
+            url: socket.__bpTraceUrl,
+            payload,
+            length: payload.length,
+          },
+          'info',
+          'WebSocket frame received'
+        );
+      });
+
+      socket.addEventListener('close', (event) => {
+        if (socket.__bpTraceClosed) {
+          return;
+        }
+        socket.__bpTraceClosed = true;
+        try {
+          globalThis.__bpTrackedWebSockets.delete(socket);
+        } catch {}
+        emit(
+          'ws.connection.closed',
+          {
+            connectionId: socket.__bpTraceId,
+            url: socket.__bpTraceUrl,
+            code: event.code,
+            reason: event.reason,
+          },
+          'warn',
+          'WebSocket closed'
+        );
+      });
+
+      return socket;
+    };
+
+    const TracedWebSocket = function(url, protocols) {
+      return arguments.length > 1
+        ? patchInstance(new NativeWebSocket(url, protocols), url)
+        : patchInstance(new NativeWebSocket(url), url);
+    };
+    TracedWebSocket.prototype = NativeWebSocket.prototype;
+    Object.setPrototypeOf(TracedWebSocket, NativeWebSocket);
+    window.WebSocket = TracedWebSocket;
+  };
+
+  window.addEventListener('error', (errorEvent) => {
+    emit(
+      'runtime.exception',
+      {
+        message: errorEvent.message,
+        filename: errorEvent.filename,
+        line: errorEvent.lineno,
+        column: errorEvent.colno,
+      },
+      'error',
+      errorEvent.message || 'Uncaught error'
+    );
+  });
+
+  window.addEventListener('unhandledrejection', (event) => {
+    const reason = event && 'reason' in event ? String(event.reason) : 'Unhandled rejection';
+    emit('runtime.unhandledRejection', { reason }, 'error', reason);
+  });
+
+  const patchPermissions = async () => {
+    if (!navigator.permissions || !navigator.permissions.query) return;
+
+    const names = ['geolocation', 'microphone', 'camera', 'notifications'];
+    for (const name of names) {
+      try {
+        const status = await navigator.permissions.query({ name });
+        emit(
+          'permission.state',
+          { name, state: status.state },
+          status.state === 'denied' ? 'warn' : 'info',
+          name + ': ' + status.state
+        );
+        status.addEventListener('change', () => {
+          emit(
+            'permission.changed',
+            { name, state: status.state },
+            status.state === 'denied' ? 'warn' : 'info',
+            name + ': ' + status.state
+          );
+        });
+      } catch {}
+    }
+  };
+
+  const patchMediaElement = (element) => {
+    if (!element || element.__bpTracePatched) return;
+    element.__bpTracePatched = true;
+
+    element.addEventListener('play', () => {
+      emit(
+        'media.playback.started',
+        { tag: element.tagName.toLowerCase(), src: element.currentSrc || element.src || null },
+        'info',
+        'Media playback started'
+      );
+    });
+
+    const onStop = () => {
+      emit(
+        'media.playback.stopped',
+        { tag: element.tagName.toLowerCase(), src: element.currentSrc || element.src || null },
+        'warn',
+        'Media playback stopped'
+      );
+    };
+
+    element.addEventListener('pause', onStop);
+    element.addEventListener('ended', onStop);
+  };
+
+  const patchMediaElements = () => {
+    document.querySelectorAll('audio,video').forEach(patchMediaElement);
+  };
+
+  patchMediaElements();
+  patchWebSocket();
+
+  if (document.documentElement) {
+    const observer = new MutationObserver(() => {
+      patchMediaElements();
+    });
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+  }
+
+  if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
+    const original = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+    navigator.mediaDevices.getUserMedia = async (...args) => {
+      emit('voice.capture.started', { constraints: args[0] || null }, 'info', 'Voice capture started');
+      try {
+        const stream = await original(...args);
+        const tracks = stream.getTracks();
+
+        for (const track of tracks) {
+          emit(
+            'media.track.started',
+            { kind: track.kind, label: track.label, readyState: track.readyState },
+            'info',
+            track.kind + ' track started'
+          );
+          track.addEventListener('ended', () => {
+            emit(
+              'media.track.ended',
+              { kind: track.kind, label: track.label, readyState: track.readyState },
+              'warn',
+              track.kind + ' track ended'
+            );
+            emit(
+              'voice.capture.stopped',
+              { kind: track.kind, label: track.label, readyState: track.readyState },
+              'warn',
+              'Voice capture stopped'
+            );
+          });
+        }
+
+        emit(
+          'voice.capture.detectedAudio',
+          { trackCount: tracks.length, kinds: tracks.map((track) => track.kind) },
+          'info',
+          'Voice capture detected audio'
+        );
+
+        return stream;
+      } catch (error) {
+        emit(
+          'voice.pipeline.notReady',
+          { message: String(error && error.message ? error.message : error) },
+          'error',
+          String(error && error.message ? error.message : error)
+        );
+        throw error;
+      }
+    };
+  }
+
+  document.addEventListener('visibilitychange', () => {
+    emit(
+      'dom.state.changed',
+      { visibilityState: document.visibilityState },
+      document.visibilityState === 'hidden' ? 'warn' : 'info',
+      'Visibility ' + document.visibilityState
+    );
+  });
+
+  patchPermissions();
+  emit('voice.pipeline.ready', { url: location.href }, 'info', 'Trace hooks ready');
+})();
+`;
+
+// src/trace/live.ts
+function globToRegex(pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const withWildcards = escaped.replace(/\*/g, ".*");
+  return new RegExp(`^${withWildcards}$`);
+}
+function readString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readStringOr(value, fallback = "") {
+  return readString(value) ?? fallback;
+}
+function formatConsoleArg(entry) {
+  return readString(entry["value"]) ?? readString(entry["description"]) ?? "";
+}
+var LiveTraceCollector = class {
+  cdp;
+  options;
+  handlers = [];
+  wsUrls = /* @__PURE__ */ new Map();
+  httpUrls = /* @__PURE__ */ new Map();
+  events = [];
+  startTime = Date.now();
+  matchRegex;
+  constructor(cdp, options = {}) {
+    this.cdp = cdp;
+    this.options = options;
+    this.matchRegex = options.match ? globToRegex(options.match) : null;
+  }
+  async start() {
+    await this.cdp.send("Runtime.enable");
+    await this.cdp.send("Page.enable");
+    await this.cdp.send("Network.enable");
+    await this.cdp.send("Runtime.addBinding", { name: TRACE_BINDING_NAME });
+    await this.cdp.send("Page.addScriptToEvaluateOnNewDocument", { source: TRACE_SCRIPT });
+    await this.cdp.send("Runtime.evaluate", { expression: TRACE_SCRIPT, awaitPromise: false });
+    if ((this.options.mode ?? "all") !== "http") {
+      this.subscribe("Network.webSocketCreated", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        const url = readStringOr(params["url"]);
+        if (!this.matchesUrl(url)) {
+          return;
+        }
+        this.wsUrls.set(requestId, url);
+        void this.emit({
+          channel: "ws",
+          event: "ws.connection.created",
+          summary: `WebSocket opened ${url}`,
+          connectionId: requestId,
+          requestId,
+          url,
+          data: { url }
+        });
+      });
+      this.subscribe("Network.webSocketFrameSent", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        const response = params["response"];
+        const payload = this.formatPayload(response?.payloadData, response?.opcode ?? 1);
+        const url = this.wsUrls.get(requestId);
+        if (this.matchRegex && !this.matchRegex.test(url ?? "") && !this.matchRegex.test(payload)) {
+          return;
+        }
+        void this.emit({
+          channel: "ws",
+          event: "ws.frame.sent",
+          summary: `WebSocket frame sent ${requestId}`,
+          connectionId: requestId,
+          requestId,
+          url,
+          data: {
+            opcode: response?.opcode ?? 1,
+            payload,
+            length: response?.payloadData?.length ?? 0
+          }
+        });
+      });
+      this.subscribe("Network.webSocketFrameReceived", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        const response = params["response"];
+        const payload = this.formatPayload(response?.payloadData, response?.opcode ?? 1);
+        const url = this.wsUrls.get(requestId);
+        if (this.matchRegex && !this.matchRegex.test(url ?? "") && !this.matchRegex.test(payload)) {
+          return;
+        }
+        void this.emit({
+          channel: "ws",
+          event: "ws.frame.received",
+          summary: `WebSocket frame received ${requestId}`,
+          connectionId: requestId,
+          requestId,
+          url,
+          data: {
+            opcode: response?.opcode ?? 1,
+            payload,
+            length: response?.payloadData?.length ?? 0
+          }
+        });
+      });
+      this.subscribe("Network.webSocketClosed", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        const url = this.wsUrls.get(requestId);
+        this.wsUrls.delete(requestId);
+        void this.emit({
+          channel: "ws",
+          event: "ws.connection.closed",
+          summary: `WebSocket closed ${requestId}`,
+          severity: "warn",
+          connectionId: requestId,
+          requestId,
+          url,
+          data: { url }
+        });
+      });
+    }
+    if ((this.options.mode ?? "all") !== "ws") {
+      this.subscribe("Network.requestWillBeSent", (params) => {
+        const request = params["request"];
+        const requestId = readStringOr(params["requestId"]);
+        const url = request?.url ?? "";
+        if (!this.matchesUrl(url)) {
+          return;
+        }
+        this.httpUrls.set(requestId, url);
+        void this.emit({
+          channel: "http",
+          event: "http.request.sent",
+          summary: `${request?.method ?? "GET"} ${url}`,
+          requestId,
+          url,
+          data: {
+            method: request?.method ?? "GET",
+            headers: request?.headers ?? {},
+            body: request?.postData ?? null
+          }
+        });
+      });
+      this.subscribe("Network.responseReceived", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        if (!this.httpUrls.has(requestId)) {
+          return;
+        }
+        const response = params["response"];
+        void this.emit({
+          channel: "http",
+          event: "http.response.received",
+          summary: `${response?.status ?? 0} ${response?.url ?? this.httpUrls.get(requestId) ?? ""}`,
+          requestId,
+          url: response?.url ?? this.httpUrls.get(requestId),
+          data: {
+            status: response?.status ?? 0,
+            headers: response?.headers ?? {},
+            mimeType: response?.mimeType ?? null
+          }
+        });
+      });
+      this.subscribe("Network.loadingFailed", (params) => {
+        const requestId = readStringOr(params["requestId"]);
+        const url = readString(params["blockedReason"]) ?? this.httpUrls.get(requestId) ?? "";
+        void this.emit({
+          channel: "http",
+          event: "http.response.failed",
+          summary: `HTTP request failed ${requestId}`,
+          severity: "error",
+          requestId,
+          url,
+          data: {
+            errorText: params["errorText"] ?? null,
+            blockedReason: params["blockedReason"] ?? null,
+            canceled: params["canceled"] ?? false
+          }
+        });
+      });
+    }
+    this.subscribe("Runtime.consoleAPICalled", (params) => {
+      const type = readStringOr(params["type"], "log");
+      if (type !== "log" && type !== "warn" && type !== "error") {
+        return;
+      }
+      const args = Array.isArray(params["args"]) ? params["args"] : [];
+      const text = args.map(formatConsoleArg).filter(Boolean).join(" ");
+      void this.emit({
+        channel: "console",
+        event: `console.${type}`,
+        severity: type === "error" ? "error" : type === "warn" ? "warn" : "info",
+        summary: text || `console.${type}`,
+        data: { args }
+      });
+    });
+    this.subscribe("Runtime.exceptionThrown", (params) => {
+      const details = params["exceptionDetails"] ?? {};
+      const text = readString(details["text"]) ?? "Runtime exception";
+      void this.emit({
+        channel: "runtime",
+        event: "runtime.exception",
+        severity: "error",
+        summary: text,
+        data: details
+      });
+    });
+    this.subscribe("Runtime.bindingCalled", (params) => {
+      if (params["name"] !== TRACE_BINDING_NAME) {
+        return;
+      }
+      const raw = readStringOr(params["payload"]);
+      try {
+        const payload = JSON.parse(raw);
+        const channel = this.channelForTraceEvent(payload.event);
+        void this.emit({
+          channel,
+          event: payload.event,
+          severity: payload.severity,
+          summary: payload.summary ?? payload.event,
+          ts: payload.ts ? new Date(payload.ts).toISOString() : void 0,
+          data: payload.data ?? {},
+          url: readString(payload.data?.["url"])
+        });
+      } catch {
+      }
+    });
+  }
+  async stop() {
+    for (const { event, handler } of this.handlers) {
+      this.cdp.off(event, handler);
+    }
+    this.handlers.length = 0;
+    return [...this.events];
+  }
+  getEvents() {
+    return [...this.events];
+  }
+  subscribe(event, handler) {
+    this.cdp.on(event, handler);
+    this.handlers.push({ event, handler });
+  }
+  matchesUrl(url) {
+    if (!this.matchRegex) {
+      return true;
+    }
+    return this.matchRegex.test(url);
+  }
+  formatPayload(payloadData, opcode) {
+    const data = payloadData ?? "";
+    const maxPayload = this.options.maxPayload ?? 256;
+    if (opcode === 2) {
+      const byteLength = Math.floor(data.length * 3 / 4);
+      return `[binary: ${byteLength} bytes]`;
+    }
+    if (data.length > maxPayload) {
+      return `${data.slice(0, maxPayload)}... [truncated, ${data.length} total]`;
+    }
+    return data;
+  }
+  channelForTraceEvent(eventName) {
+    if (eventName.startsWith("ws.")) return "ws";
+    if (eventName.startsWith("http.")) return "http";
+    if (eventName.startsWith("console.")) return "console";
+    if (eventName.startsWith("permission.")) return "permission";
+    if (eventName.startsWith("media.")) return "media";
+    if (eventName.startsWith("voice.")) return "voice";
+    if (eventName.startsWith("dom.")) return "dom";
+    if (eventName.startsWith("runtime.")) return "runtime";
+    return "session";
+  }
+  async emit(event) {
+    const normalized = normalizeTraceEvent({
+      traceId: event.traceId ?? createTraceId(event.channel),
+      sessionId: this.options.sessionId,
+      targetId: this.options.targetId,
+      elapsedMs: event.elapsedMs ?? Date.now() - this.startTime,
+      ...event
+    });
+    this.events.push(normalized);
+    await this.options.onEvent?.(normalized);
+  }
+};
+
+// src/actions/executor.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RECORDING_SKIP_ACTIONS = [
+  "wait",
+  "snapshot",
+  "forms",
+  "text",
+  "screenshot"
+];
+function readString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function readStringOr2(value, fallback = "") {
+  return readString2(value) ?? fallback;
+}
+function formatConsoleArg2(entry) {
+  return readString2(entry["value"]) ?? readString2(entry["description"]) ?? "";
+}
+function loadExistingRecording(manifestPath) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    if (raw.version === 1) {
+      const legacy = raw;
+      return {
+        frames: Array.isArray(legacy.frames) ? legacy.frames : [],
+        traceEvents: [],
+        recordedAt: legacy.recordedAt,
+        startUrl: legacy.startUrl
+      };
+    }
+    const artifact = canonicalizeRecordingArtifact(raw);
+    const screenshotsByAction = new Map(artifact.screenshots.map((shot) => [shot.actionId, shot]));
+    const frames = artifact.actions.map((action, index) => {
+      const screenshot = screenshotsByAction.get(action.id);
+      return {
+        seq: index + 1,
+        timestamp: Date.parse(action.ts),
+        action: action.action,
+        selector: action.selector,
+        selectorUsed: action.selectorUsed,
+        value: action.value,
+        url: action.url,
+        coordinates: action.coordinates,
+        boundingBox: action.boundingBox,
+        success: action.success,
+        durationMs: action.durationMs,
+        error: action.error,
+        screenshot: screenshot?.file ?? "",
+        pageUrl: action.pageUrl,
+        pageTitle: action.pageTitle,
+        stepIndex: action.stepIndex,
+        actionId: action.id
+      };
+    });
+    return {
+      frames,
+      traceEvents: artifact.trace.events,
+      recordedAt: artifact.recordedAt,
+      startUrl: artifact.session.startUrl
+    };
+  } catch {
+    return { frames: [], traceEvents: [] };
+  }
+}
 function classifyFailure(error) {
   if (error instanceof ElementNotFoundError) {
     return { reason: "missing" };
@@ -1147,6 +1889,9 @@ var BatchExecutor = class {
     const results = [];
     const startTime = Date.now();
     const recording = options.record ? this.createRecordingContext(options.record) : null;
+    if (steps.some((step) => step.action === "waitForWsMessage")) {
+      await this.ensureTraceHooks();
+    }
     const startUrl = recording ? await this.getPageUrlSafe() : "";
     let stoppedAtIndex;
     for (let i = 0; i < steps.length; i++) {
@@ -1156,6 +1901,26 @@ var BatchExecutor = class {
       const retryDelay = step.retryDelay ?? 500;
       let lastError;
       let succeeded = false;
+      if (recording) {
+        recording.traceEvents.push(
+          normalizeTraceEvent({
+            traceId: createTraceId("action"),
+            elapsedMs: Date.now() - startTime,
+            channel: "action",
+            event: "action.started",
+            summary: `${step.action}${step.selector ? ` ${Array.isArray(step.selector) ? step.selector[0] : step.selector}` : ""}`,
+            data: {
+              action: step.action,
+              selector: step.selector ?? null,
+              url: step.url ?? null
+            },
+            actionId: `action-${i + 1}`,
+            stepIndex: i,
+            selector: step.selector,
+            url: step.url
+          })
+        );
+      }
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         if (attempt > 0) {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
@@ -1179,6 +1944,28 @@ var BatchExecutor = class {
           if (recording && !recording.skipActions.has(step.action)) {
             await this.captureRecordingFrame(step, stepResult, recording);
           }
+          if (recording) {
+            recording.traceEvents.push(
+              normalizeTraceEvent({
+                traceId: createTraceId("action"),
+                elapsedMs: Date.now() - startTime,
+                channel: "action",
+                event: "action.succeeded",
+                summary: `${step.action} succeeded`,
+                data: {
+                  action: step.action,
+                  selector: step.selector ?? null,
+                  selectorUsed: result.selectorUsed ?? null,
+                  durationMs: Date.now() - stepStart
+                },
+                actionId: `action-${i + 1}`,
+                stepIndex: i,
+                selector: step.selector,
+                selectorUsed: result.selectorUsed,
+                url: step.url
+              })
+            );
+          }
           results.push(stepResult);
           succeeded = true;
           break;
@@ -1216,6 +2003,28 @@ var BatchExecutor = class {
         if (recording && !recording.skipActions.has(step.action)) {
           await this.captureRecordingFrame(step, failedResult, recording);
         }
+        if (recording) {
+          recording.traceEvents.push(
+            normalizeTraceEvent({
+              traceId: createTraceId("action"),
+              elapsedMs: Date.now() - startTime,
+              channel: "action",
+              event: "action.failed",
+              severity: "error",
+              summary: `${step.action} failed: ${errorMessage}`,
+              data: {
+                action: step.action,
+                selector: step.selector ?? null,
+                error: errorMessage,
+                reason
+              },
+              actionId: `action-${i + 1}`,
+              stepIndex: i,
+              selector: step.selector,
+              url: step.url
+            })
+          );
+        }
         results.push(failedResult);
         if (onFail === "stop" && !step.optional) {
           stoppedAtIndex = i;
@@ -1231,7 +2040,8 @@ var BatchExecutor = class {
         recording,
         startTime,
         startUrl,
-        allSuccess
+        allSuccess,
+        steps
       );
     }
     return {
@@ -1246,20 +2056,14 @@ var BatchExecutor = class {
     const baseDir = record.outputDir ?? join(process.cwd(), ".browser-pilot");
     const screenshotDir = join(baseDir, "screenshots");
     const manifestPath = join(baseDir, "recording.json");
-    let existingFrames = [];
-    try {
-      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-      if (existing.frames && Array.isArray(existing.frames)) {
-        existingFrames = existing.frames;
-      }
-    } catch {
-    }
+    const existing = loadExistingRecording(manifestPath);
     fs.mkdirSync(screenshotDir, { recursive: true });
     return {
       baseDir,
       screenshotDir,
       sessionId: record.sessionId ?? this.page.targetId,
-      frames: existingFrames,
+      frames: existing.frames,
+      traceEvents: existing.traceEvents,
       format: record.format ?? "webp",
       quality: Math.max(0, Math.min(100, record.quality ?? 40)),
       highlights: record.highlights !== false,
@@ -1315,6 +2119,7 @@ var BatchExecutor = class {
         timestamp: ts,
         action: stepResult.action,
         selector: stepResult.selectorUsed ?? (Array.isArray(step.selector) ? step.selector[0] : step.selector),
+        selectorUsed: stepResult.selectorUsed,
         value: redactValueForRecording(
           typeof step.value === "string" ? step.value : void 0,
           targetMetadata
@@ -1327,7 +2132,9 @@ var BatchExecutor = class {
         error: stepResult.error,
         screenshot: filename,
         pageUrl,
-        pageTitle
+        pageTitle,
+        stepIndex: stepResult.index,
+        actionId: `action-${stepResult.index + 1}`
       });
     } catch {
     } finally {
@@ -1339,45 +2146,31 @@ var BatchExecutor = class {
   /**
    * Write recording manifest to disk
    */
-  async writeRecordingManifest(recording, startTime, startUrl, success) {
+  async writeRecordingManifest(recording, startTime, startUrl, success, steps) {
     let endUrl = startUrl;
-    let viewport = { width: 1280, height: 720 };
     try {
       endUrl = await this.page.url();
     } catch {
     }
-    try {
-      const metrics = await this.page.cdpClient.send("Page.getLayoutMetrics");
-      viewport = {
-        width: metrics.cssVisualViewport.clientWidth,
-        height: metrics.cssVisualViewport.clientHeight
-      };
-    } catch {
-    }
     const manifestPath = join(recording.baseDir, "recording.json");
     let recordedAt = new Date(startTime).toISOString();
     let originalStartUrl = startUrl;
-    try {
-      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-      if (existing.recordedAt) recordedAt = existing.recordedAt;
-      if (existing.startUrl) originalStartUrl = existing.startUrl;
-    } catch {
-    }
-    const firstFrameTime = recording.frames[0]?.timestamp ?? startTime;
-    const totalDurationMs = Date.now() - Math.min(firstFrameTime, startTime);
-    const manifest = {
-      version: 1,
+    const existing = loadExistingRecording(manifestPath);
+    if (existing.recordedAt) recordedAt = existing.recordedAt;
+    if (existing.startUrl) originalStartUrl = existing.startUrl;
+    const manifest = createRecordingManifest({
       recordedAt,
       sessionId: recording.sessionId,
       startUrl: originalStartUrl,
       endUrl,
-      viewport,
-      format: recording.format,
-      quality: recording.quality,
-      totalDurationMs,
-      success,
-      frames: recording.frames
-    };
+      targetId: this.page.targetId,
+      steps,
+      frames: recording.frames,
+      traceEvents: recording.traceEvents,
+      notes: success ? [] : ["Replay ended with at least one failed action."],
+      recordingManifest: "recording.json",
+      screenshotDir: "screenshots/"
+    });
     fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
     return manifestPath;
   }
@@ -1660,6 +2453,39 @@ var BatchExecutor = class {
         }
         return { selectorUsed: usedSelector, value: actual };
       }
+      case "waitForWsMessage": {
+        if (typeof step.match !== "string") {
+          throw new Error("waitForWsMessage requires match");
+        }
+        const message = await this.waitForWsMessage(step.match, step.where, timeout);
+        return { value: message };
+      }
+      case "assertNoConsoleErrors": {
+        await this.assertNoConsoleErrors(step.windowMs ?? timeout);
+        return {};
+      }
+      case "assertTextChanged": {
+        const selector = Array.isArray(step.selector) ? step.selector[0] : step.selector;
+        if (typeof step.to !== "string") {
+          throw new Error("assertTextChanged requires to");
+        }
+        const text = await this.assertTextChanged(selector, step.from, step.to, timeout);
+        return { selectorUsed: selector, text };
+      }
+      case "assertPermission": {
+        if (!step.name || !step.state) {
+          throw new Error("assertPermission requires name and state");
+        }
+        const permission = await this.assertPermission(step.name, step.state);
+        return { value: permission };
+      }
+      case "assertMediaTrackLive": {
+        if (!step.kind) {
+          throw new Error("assertMediaTrackLive requires kind");
+        }
+        const media = await this.assertMediaTrackLive(step.kind);
+        return { value: media };
+      }
       default: {
         const action = step.action;
         const aliases = {
@@ -1713,7 +2539,7 @@ var BatchExecutor = class {
         };
         const suggestion = aliases[action.toLowerCase()];
         const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
-        const valid = "goto, click, fill, type, select, check, uncheck, submit, press, shortcut, focus, hover, scroll, wait, snapshot, forms, screenshot, evaluate, text, newTab, closeTab, switchFrame, switchToMain, assertVisible, assertExists, assertText, assertUrl, assertValue";
+        const valid = "goto, click, fill, type, select, check, uncheck, submit, press, shortcut, focus, hover, scroll, wait, snapshot, forms, screenshot, evaluate, text, newTab, closeTab, switchFrame, switchToMain, assertVisible, assertExists, assertText, assertUrl, assertValue, waitForWsMessage, assertNoConsoleErrors, assertTextChanged, assertPermission, assertMediaTrackLive";
         throw new Error(`Unknown action "${action}".${hint}
 
 Valid actions: ${valid}`);
@@ -1729,6 +2555,237 @@ Valid actions: ${valid}`);
     if (matched) return matched;
     return Array.isArray(selector) ? selector[0] : selector;
   }
+  async ensureTraceHooks() {
+    await this.page.cdpClient.send("Runtime.enable");
+    await this.page.cdpClient.send("Page.enable");
+    await this.page.cdpClient.send("Network.enable");
+    try {
+      await this.page.cdpClient.send("Runtime.addBinding", { name: TRACE_BINDING_NAME });
+    } catch {
+    }
+    await this.page.cdpClient.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: TRACE_SCRIPT
+    });
+    await this.page.cdpClient.send("Runtime.evaluate", {
+      expression: TRACE_SCRIPT,
+      awaitPromise: false
+    });
+  }
+  async waitForWsMessage(match, where, timeout) {
+    await this.ensureTraceHooks();
+    const regex = globToRegex(match);
+    const wsUrls = /* @__PURE__ */ new Map();
+    const recentMatch = await this.findRecentWsMessage(regex, where);
+    if (recentMatch) {
+      return recentMatch;
+    }
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        this.page.cdpClient.off("Network.webSocketCreated", onCreated);
+        this.page.cdpClient.off("Network.webSocketFrameReceived", onFrame);
+        this.page.cdpClient.off("Runtime.bindingCalled", onBinding);
+        clearTimeout(timer);
+      };
+      const onCreated = (params) => {
+        wsUrls.set(readStringOr2(params["requestId"]), readStringOr2(params["url"]));
+      };
+      const onFrame = (params) => {
+        const requestId = readStringOr2(params["requestId"]);
+        const response = params["response"] ?? {};
+        const payload = response.payloadData ?? "";
+        const url = wsUrls.get(requestId) ?? "";
+        if (!regex.test(url) && !regex.test(payload)) {
+          return;
+        }
+        if (where && !this.payloadMatchesWhere(payload, where)) {
+          return;
+        }
+        cleanup();
+        resolve({ requestId, url, payload });
+      };
+      const onBinding = (params) => {
+        if (params["name"] !== TRACE_BINDING_NAME) {
+          return;
+        }
+        try {
+          const parsed = JSON.parse(readStringOr2(params["payload"]));
+          if (parsed.event !== "ws.frame.received") {
+            return;
+          }
+          const data = parsed.data ?? {};
+          const payload = readStringOr2(data["payload"]);
+          const url = readStringOr2(data["url"]);
+          if (!regex.test(url) && !regex.test(payload)) {
+            return;
+          }
+          if (where && !this.payloadMatchesWhere(payload, where)) {
+            return;
+          }
+          cleanup();
+          resolve({
+            requestId: readStringOr2(data["connectionId"]),
+            url,
+            payload
+          });
+        } catch {
+        }
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Timed out waiting for WebSocket message matching ${match}`));
+      }, timeout);
+      this.page.cdpClient.on("Network.webSocketCreated", onCreated);
+      this.page.cdpClient.on("Network.webSocketFrameReceived", onFrame);
+      this.page.cdpClient.on("Runtime.bindingCalled", onBinding);
+    });
+  }
+  payloadMatchesWhere(payload, where) {
+    try {
+      const parsed = JSON.parse(payload);
+      return Object.entries(where).every(([key, expected]) => {
+        const actual = key.split(".").reduce((current, part) => {
+          if (!current || typeof current !== "object") {
+            return void 0;
+          }
+          return current[part];
+        }, parsed);
+        return actual === expected;
+      });
+    } catch {
+      return false;
+    }
+  }
+  async findRecentWsMessage(regex, where) {
+    const recent = await this.page.evaluate(
+      "(() => Array.isArray(globalThis.__bpTraceRecentEvents) ? globalThis.__bpTraceRecentEvents : [])()"
+    );
+    if (!Array.isArray(recent)) {
+      return null;
+    }
+    for (let i = recent.length - 1; i >= 0; i--) {
+      const entry = recent[i];
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const record = entry;
+      const event = readStringOr2(record["event"]);
+      if (event !== "ws.frame.received") {
+        continue;
+      }
+      const data = record["data"] ?? {};
+      const payload = readStringOr2(data["payload"]);
+      const url = readStringOr2(data["url"]);
+      if (!regex.test(url) && !regex.test(payload)) {
+        continue;
+      }
+      if (where && !this.payloadMatchesWhere(payload, where)) {
+        continue;
+      }
+      return {
+        requestId: readStringOr2(data["connectionId"]),
+        url,
+        payload
+      };
+    }
+    return null;
+  }
+  async assertNoConsoleErrors(windowMs) {
+    await this.page.cdpClient.send("Runtime.enable");
+    return new Promise((resolve, reject) => {
+      const errors = [];
+      const cleanup = () => {
+        this.page.cdpClient.off("Runtime.consoleAPICalled", onConsole);
+        this.page.cdpClient.off("Runtime.exceptionThrown", onException);
+        clearTimeout(timer);
+      };
+      const onConsole = (params) => {
+        if (params["type"] !== "error") {
+          return;
+        }
+        const args = Array.isArray(params["args"]) ? params["args"] : [];
+        errors.push(args.map(formatConsoleArg2).filter(Boolean).join(" "));
+      };
+      const onException = (params) => {
+        const details = params["exceptionDetails"] ?? {};
+        errors.push(readString2(details["text"]) ?? "Runtime exception");
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        if (errors.length > 0) {
+          reject(new Error(`Console errors detected: ${errors.join(" | ")}`));
+          return;
+        }
+        resolve();
+      }, windowMs);
+      this.page.cdpClient.on("Runtime.consoleAPICalled", onConsole);
+      this.page.cdpClient.on("Runtime.exceptionThrown", onException);
+    });
+  }
+  async assertTextChanged(selector, from, to, timeout) {
+    const initialText = from ?? await this.page.text(selector);
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      const text = await this.page.text(selector);
+      if (text !== initialText && text.includes(to)) {
+        return text;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    throw new Error(`Text did not change to include ${JSON.stringify(to)}`);
+  }
+  async assertPermission(name, state) {
+    const result = await this.page.evaluate(
+      `(() => navigator.permissions.query({ name: ${JSON.stringify(name)} }).then((status) => ({ name: ${JSON.stringify(name)}, state: status.state })))()`
+    );
+    if (!result || typeof result !== "object" || result.state !== state) {
+      throw new Error(`Permission ${name} is not ${state}`);
+    }
+    return result;
+  }
+  async assertMediaTrackLive(kind) {
+    const result = await this.page.evaluate(
+      `(() => {
+        const requestedKind = ${JSON.stringify(kind)};
+        const mediaElements = Array.from(document.querySelectorAll('audio,video')).map((el) => {
+          const tracks = [];
+          if (el.srcObject && typeof el.srcObject.getTracks === 'function') {
+            tracks.push(...el.srcObject.getTracks());
+          }
+          return {
+            tag: el.tagName.toLowerCase(),
+            paused: !!el.paused,
+            tracks: tracks.map((track) => ({
+              kind: track.kind,
+              readyState: track.readyState,
+              enabled: track.enabled,
+              label: track.label,
+            })),
+          };
+        });
+
+        const globalTracks =
+          window.__bpStream && typeof window.__bpStream.getTracks === 'function'
+            ? window.__bpStream.getTracks().map((track) => ({
+                kind: track.kind,
+                readyState: track.readyState,
+                enabled: track.enabled,
+                label: track.label,
+              }))
+            : [];
+
+        const liveTracks = mediaElements
+          .flatMap((entry) => entry.tracks)
+          .concat(globalTracks)
+          .filter((track) => track.kind === requestedKind && track.readyState === 'live');
+
+        return { live: liveTracks.length > 0, mediaElements, globalTracks, liveTracks };
+      })()`
+    );
+    if (!result || typeof result !== "object" || !result.live) {
+      throw new Error(`No live ${kind} media track detected`);
+    }
+    return result;
+  }
 };
 function addBatchToPage(page) {
   const executor = new BatchExecutor(page);
@@ -1859,7 +2916,7 @@ var ACTION_RULES = {
       value: { type: "string|string[]" },
       trigger: { type: "string|string[]" },
       option: { type: "string|string[]" },
-      match: { type: "string", enum: ["text", "value", "contains"] }
+      match: { type: "string" }
     }
   },
   check: {
@@ -1990,6 +3047,38 @@ var ACTION_RULES = {
       expect: { type: "string" },
       value: { type: "string" }
     }
+  },
+  waitForWsMessage: {
+    required: { match: { type: "string" } },
+    optional: {
+      where: { type: "object" }
+    }
+  },
+  assertNoConsoleErrors: {
+    required: {},
+    optional: {
+      windowMs: { type: "number" }
+    }
+  },
+  assertTextChanged: {
+    required: { to: { type: "string" } },
+    optional: {
+      selector: { type: "string|string[]" },
+      from: { type: "string" }
+    }
+  },
+  assertPermission: {
+    required: {
+      name: { type: "string" },
+      state: { type: "string" }
+    },
+    optional: {}
+  },
+  assertMediaTrackLive: {
+    required: {
+      kind: { type: "string", enum: ["audio", "video"] }
+    },
+    optional: {}
   }
 };
 var VALID_ACTIONS = Object.keys(ACTION_RULES);
@@ -2013,6 +3102,7 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "trigger",
   "option",
   "match",
+  "where",
   "x",
   "y",
   "direction",
@@ -2022,7 +3112,13 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "fullPage",
   "expect",
   "retry",
-  "retryDelay"
+  "retryDelay",
+  "from",
+  "to",
+  "name",
+  "state",
+  "kind",
+  "windowMs"
 ]);
 function resolveAction(name) {
   if (VALID_ACTIONS.includes(name)) {
@@ -2095,6 +3191,11 @@ function checkFieldType(value, rule) {
         return `expected boolean or "auto", got ${typeof value}`;
       }
       return null;
+    case "object":
+      if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return `expected object, got ${Array.isArray(value) ? "array" : typeof value}`;
+      }
+      return null;
     default: {
       const _exhaustive = rule.type;
       return `unknown type: ${_exhaustive}`;
@@ -2389,6 +3490,10 @@ async function grantAudioPermissions(cdp, origin) {
   await cdp.send("Page.addScriptToEvaluateOnNewDocument", {
     source: PERMISSIONS_OVERRIDE_SCRIPT
   });
+  await cdp.send("Runtime.evaluate", {
+    expression: PERMISSIONS_OVERRIDE_SCRIPT,
+    awaitPromise: false
+  });
 }
 var PERMISSIONS_OVERRIDE_SCRIPT = `
 (function() {
@@ -3347,7 +4452,7 @@ var AudioOutput = class {
       awaitPromise: false
     });
     this.capturing = false;
-    await sleep3(250);
+    await sleep2(250);
     return this.mergeChunks();
   }
   /**
@@ -3563,7 +4668,7 @@ function emptyCaptureResult() {
     chunkCount: 0
   };
 }
-function sleep3(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -4104,7 +5209,7 @@ async function isElementAttached(cdp, selector, contextId) {
   const result = await cdp.send("Runtime.evaluate", params);
   return result.result.value === true;
 }
-function sleep4(ms) {
+function sleep3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function isPageStatic(cdp, windowMs = 200, contextId) {
@@ -4172,7 +5277,7 @@ async function waitForAnyElement(cdp, selectors, options = {}) {
     }
   }
   while (Date.now() < deadline) {
-    await sleep4(pollInterval);
+    await sleep3(pollInterval);
     for (const selector of selectors) {
       if (await checkSelector(selector)) {
         return { success: true, selector, waitedMs: Date.now() - startTime };
@@ -4233,7 +5338,7 @@ async function waitForNavigation(cdp, options = {}) {
     cleanup.push(() => cdp.off("Page.lifecycleEvent", onLifecycle));
     const pollUrl = async () => {
       while (!resolved && Date.now() < startTime + timeout) {
-        await sleep4(100);
+        await sleep3(100);
         if (resolved) return;
         try {
           const currentUrl = await getCurrentUrl(cdp);
@@ -4838,7 +5943,7 @@ var Page = class {
         } catch (e) {
           if (options.optional) return false;
           if (e instanceof ActionabilityError && e.failureType === "hitTarget" && attempt < HIT_TARGET_RETRIES - 1) {
-            await sleep5(HIT_TARGET_DELAY);
+            await sleep4(HIT_TARGET_DELAY);
             await this.cdp.send("DOM.scrollIntoViewIfNeeded", { nodeId: element.nodeId });
             continue;
           }
@@ -5013,7 +6118,7 @@ var Page = class {
           await this.cdp.send("Input.insertText", { text: char });
         }
         if (delay > 0) {
-          await sleep5(delay);
+          await sleep4(delay);
         }
       }
       if (options.blur) {
@@ -5109,7 +6214,7 @@ var Page = class {
         state: "visible",
         timeout: 500,
         contextId: this.currentFrameContextId ?? void 0
-      }).catch(() => sleep5(100));
+      }).catch(() => sleep4(100));
       const optionHandle = await this.evaluateInFrame(
         `(() => {
           const selectors = ${JSON.stringify(optionSelectors)};
@@ -5326,7 +6431,7 @@ var Page = class {
               () => "navigation"
             ),
             this.waitForDOMMutation({ timeout: 1e3 }).then(() => "mutation"),
-            sleep5(1500).then(() => "timeout")
+            sleep4(1500).then(() => "timeout")
           ]);
         }
         return true;
@@ -5346,7 +6451,7 @@ var Page = class {
               (success) => success ? "nav" : null
             ),
             this.waitForDOMMutation({ timeout: 1e3 }).then(() => "mutation"),
-            sleep5(1500).then(() => "timeout")
+            sleep4(1500).then(() => "timeout")
           ]);
           if (navigationDetected === "nav") {
             return true;
@@ -5360,7 +6465,7 @@ var Page = class {
         if (shouldWait === true) {
           await this.waitForNavigation({ timeout: options.timeout ?? DEFAULT_TIMEOUT2 });
         } else if (shouldWait === "auto") {
-          await sleep5(100);
+          await sleep4(100);
         }
       }
       return true;
@@ -6757,7 +7862,7 @@ var Page = class {
       try {
         await Promise.race([
           this.dialogHandler(dialog),
-          sleep5(DIALOG_TIMEOUT).then(() => {
+          sleep4(DIALOG_TIMEOUT).then(() => {
             console.warn("[browser-pilot] Dialog handler timed out after 5s, auto-dismissing");
             return dialog.dismiss();
           })
@@ -6882,7 +7987,7 @@ var Page = class {
           if (attempt < retries) {
             this.rootNodeId = null;
             this.currentFrameContextId = null;
-            await sleep5(delay);
+            await sleep4(delay);
             continue;
           }
         }
@@ -7466,7 +8571,7 @@ var Page = class {
     const start = Date.now();
     await this.audioOutput.start();
     if (options.preDelay && options.preDelay > 0) {
-      await sleep5(options.preDelay);
+      await sleep4(options.preDelay);
     }
     const inputDone = this.audioInput.play(options.input, {
       waitForEnd: !!options.sendSelector
@@ -7534,255 +8639,27 @@ var Page = class {
     });
   }
 };
-function sleep5(ms) {
+function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-// src/browser/browser.ts
-function scoreTarget(t) {
-  let score = 0;
-  if (t.url.startsWith("http://") || t.url.startsWith("https://")) score += 10;
-  if (t.url.startsWith("chrome://")) score -= 20;
-  if (t.url.startsWith("chrome-extension://")) score -= 15;
-  if (t.url.startsWith("devtools://")) score -= 25;
-  if (t.url === "about:blank") score -= 5;
-  if (!t.attached) score += 3;
-  if (t.title && t.title.length > 0) score += 2;
-  return score;
-}
-function pickBestTarget(targets) {
-  if (targets.length === 0) return void 0;
-  const sorted = [...targets].sort((a, b) => scoreTarget(b) - scoreTarget(a));
-  return sorted[0].targetId;
-}
-var Browser = class _Browser {
-  cdp;
-  providerSession;
-  pages = /* @__PURE__ */ new Map();
-  pageCounter = 0;
-  constructor(cdp, _provider, providerSession, _options) {
-    this.cdp = cdp;
-    this.providerSession = providerSession;
-  }
-  /**
-   * Create a Browser from an existing CDPClient (used by daemon fast-path).
-   * The caller is responsible for the CDP connection lifecycle.
-   */
-  static fromCDP(cdp, sessionInfo) {
-    const providerSession = {
-      wsUrl: sessionInfo.wsUrl,
-      sessionId: sessionInfo.sessionId,
-      async close() {
-      }
-    };
-    const provider = {
-      name: sessionInfo.provider ?? "daemon",
-      async createSession() {
-        return providerSession;
-      }
-    };
-    return new _Browser(cdp, provider, providerSession, { provider: "generic" });
-  }
-  /**
-   * Connect to a browser instance
-   */
-  static async connect(options) {
-    const provider = createProvider(options);
-    const session = await provider.createSession(options.session);
-    const cdp = await createCDPClient(session.wsUrl, {
-      debug: options.debug,
-      timeout: options.timeout
-    });
-    return new _Browser(cdp, provider, session, options);
-  }
-  /**
-   * Get or create a page by name.
-   * If no name is provided, returns the first available page or creates a new one.
-   *
-   * Target selection heuristics (when no targetId is specified):
-   * - Prefer http/https URLs over chrome://, devtools://, about:blank
-   * - Prefer unattached targets (not already controlled by another client)
-   * - Filter by targetUrl if provided
-   */
-  async page(name, options) {
-    const pageName = name ?? "default";
-    const cached = this.pages.get(pageName);
-    if (cached) return cached;
-    const targets = await this.cdp.send(
-      "Target.getTargets",
-      void 0,
-      null
-    );
-    let pageTargets = targets.targetInfos.filter((t) => t.type === "page");
-    if (options?.targetUrl) {
-      const urlFilter = options.targetUrl;
-      const filtered = pageTargets.filter((t) => t.url.includes(urlFilter));
-      if (filtered.length > 0) {
-        pageTargets = filtered;
-      } else {
-        console.warn(
-          `[browser-pilot] No targets match URL filter "${urlFilter}", falling back to all page targets`
-        );
-      }
-    }
-    let targetId;
-    if (options?.targetId) {
-      const targetExists = targets.targetInfos.some(
-        (t) => t.type === "page" && t.targetId === options.targetId
-      );
-      if (targetExists) {
-        targetId = options.targetId;
-      } else {
-        console.warn(`[browser-pilot] Target ${options.targetId} no longer exists, falling back`);
-        targetId = pickBestTarget(pageTargets) ?? (await this.cdp.send(
-          "Target.createTarget",
-          {
-            url: "about:blank"
-          },
-          null
-        )).targetId;
-      }
-    } else if (pageTargets.length > 0) {
-      targetId = pickBestTarget(pageTargets);
-    } else {
-      const result = await this.cdp.send(
-        "Target.createTarget",
-        {
-          url: "about:blank"
-        },
-        null
-      );
-      targetId = result.targetId;
-    }
-    await this.cdp.attachToTarget(targetId);
-    const page = new Page(this.cdp, targetId);
-    await page.init();
-    const minViewport = options?.minViewport !== void 0 ? options.minViewport : { width: 200, height: 200 };
-    if (minViewport !== false) {
-      try {
-        const viewport = await page.evaluate(
-          "({ w: window.innerWidth, h: window.innerHeight })"
-        );
-        if (viewport.w < minViewport.width || viewport.h < minViewport.height) {
-          console.warn(
-            `[browser-pilot] Attached target has small viewport (${viewport.w}x${viewport.h}). Applying default viewport override (1280x720). Use { minViewport: false } to disable this check.`
-          );
-          await page.setViewport({ width: 1280, height: 720 });
-        }
-      } catch {
-      }
-    }
-    this.pages.set(pageName, page);
-    return page;
-  }
-  /**
-   * Create a new page (tab)
-   */
-  async newPage(url = "about:blank") {
-    const result = await this.cdp.send(
-      "Target.createTarget",
-      {
-        url
-      },
-      null
-    );
-    await this.cdp.attachToTarget(result.targetId);
-    const page = new Page(this.cdp, result.targetId);
-    await page.init();
-    const name = `page-${++this.pageCounter}`;
-    this.pages.set(name, page);
-    return page;
-  }
-  /**
-   * Close a page by name
-   */
-  async closePage(name) {
-    const page = this.pages.get(name);
-    if (!page) return;
-    const targetId = page.targetId;
-    await this.cdp.send("Target.closeTarget", { targetId }, null);
-    this.pages.delete(name);
-    const deadline = Date.now() + 5e3;
-    while (Date.now() < deadline) {
-      const { targetInfos } = await this.cdp.send(
-        "Target.getTargets",
-        void 0,
-        null
-      );
-      if (!targetInfos.some((t) => t.targetId === targetId)) return;
-      await new Promise((r) => setTimeout(r, 50));
-    }
-  }
-  /**
-   * List all page targets in the connected browser.
-   */
-  async listTargets() {
-    const { targetInfos } = await this.cdp.send(
-      "Target.getTargets",
-      void 0,
-      null
-    );
-    return targetInfos.filter((target) => target.type === "page");
-  }
-  /**
-   * Get the WebSocket URL for this browser connection
-   */
-  get wsUrl() {
-    return this.providerSession.wsUrl;
-  }
-  /**
-   * Get the provider session ID (for resumption)
-   */
-  get sessionId() {
-    return this.providerSession.sessionId;
-  }
-  /**
-   * Get provider metadata
-   */
-  get metadata() {
-    return this.providerSession.metadata;
-  }
-  /**
-   * Check if connected
-   */
-  get isConnected() {
-    return this.cdp.isConnected;
-  }
-  /**
-   * Disconnect from the browser (keeps provider session alive for reconnection)
-   */
-  async disconnect() {
-    this.pages.clear();
-    await this.cdp.close();
-  }
-  /**
-   * Close the browser session completely
-   */
-  async close() {
-    this.pages.clear();
-    await this.cdp.close();
-    await this.providerSession.close();
-  }
-  /**
-   * Get the underlying CDP client (for advanced usage)
-   */
-  get cdpClient() {
-    return this.cdp;
-  }
-};
-function connect(options) {
-  return Browser.connect(options);
-}
-
 export {
   pcmToWav,
   SENSITIVE_AUTOCOMPLETE_TOKENS,
   redactValueForRecording,
   fuzzyMatchElements,
+  buildTraceSummary,
+  buildTraceSummaries,
+  createRecordingManifest,
+  canonicalizeRecordingArtifact,
+  createTraceId,
+  normalizeTraceEvent,
+  TRACE_BINDING_NAME,
+  TRACE_SCRIPT,
+  LiveTraceCollector,
   addBatchToPage,
   validateSteps,
-  getBrowserWebSocketUrl,
+  grantAudioPermissions,
   DEEP_QUERY_SCRIPT,
-  Browser,
-  connect
+  Page
 };