browser-pilot 0.0.14 → 0.0.16

package/dist/actions.cjs

@@ -560,6 +560,624 @@ var CDPError = class extends Error {
   }
 };
 
+// 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 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}$`);
+}
+
 // src/actions/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
 var DEFAULT_RECORDING_SKIP_ACTIONS = [
@@ -569,6 +1187,61 @@ var DEFAULT_RECORDING_SKIP_ACTIONS = [
   "text",
   "screenshot"
 ];
+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"]) ?? "";
+}
+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" };
@@ -649,6 +1322,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++) {
@@ -658,6 +1334,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));
@@ -681,6 +1377,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;
@@ -718,6 +1436,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;
@@ -733,7 +1473,8 @@ var BatchExecutor = class {
         recording,
         startTime,
         startUrl,
-        allSuccess
+        allSuccess,
+        steps
       );
     }
     return {
@@ -748,20 +1489,14 @@ var BatchExecutor = class {
     const baseDir = record.outputDir ?? (0, import_node_path.join)(process.cwd(), ".browser-pilot");
     const screenshotDir = (0, import_node_path.join)(baseDir, "screenshots");
     const manifestPath = (0, import_node_path.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,
@@ -817,6 +1552,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
@@ -829,7 +1565,9 @@ var BatchExecutor = class {
         error: stepResult.error,
         screenshot: filename,
         pageUrl,
-        pageTitle
+        pageTitle,
+        stepIndex: stepResult.index,
+        actionId: `action-${stepResult.index + 1}`
       });
     } catch {
     } finally {
@@ -841,45 +1579,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 = (0, import_node_path.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;
   }
@@ -1162,6 +1886,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 = {
@@ -1215,7 +1972,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}`);
@@ -1231,6 +1988,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(readStringOr(params["requestId"]), readStringOr(params["url"]));
+      };
+      const onFrame = (params) => {
+        const requestId = readStringOr(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(readStringOr(params["payload"]));
+          if (parsed.event !== "ws.frame.received") {
+            return;
+          }
+          const data = parsed.data ?? {};
+          const payload = readStringOr(data["payload"]);
+          const url = readStringOr(data["url"]);
+          if (!regex.test(url) && !regex.test(payload)) {
+            return;
+          }
+          if (where && !this.payloadMatchesWhere(payload, where)) {
+            return;
+          }
+          cleanup();
+          resolve({
+            requestId: readStringOr(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 = readStringOr(record["event"]);
+      if (event !== "ws.frame.received") {
+        continue;
+      }
+      const data = record["data"] ?? {};
+      const payload = readStringOr(data["payload"]);
+      const url = readStringOr(data["url"]);
+      if (!regex.test(url) && !regex.test(payload)) {
+        continue;
+      }
+      if (where && !this.payloadMatchesWhere(payload, where)) {
+        continue;
+      }
+      return {
+        requestId: readStringOr(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(formatConsoleArg).filter(Boolean).join(" "));
+      };
+      const onException = (params) => {
+        const details = params["exceptionDetails"] ?? {};
+        errors.push(readString(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);
@@ -1361,7 +2349,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: {
@@ -1492,6 +2480,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);
@@ -1515,6 +2535,7 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "trigger",
   "option",
   "match",
+  "where",
   "x",
   "y",
   "direction",
@@ -1524,7 +2545,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)) {
@@ -1597,6 +2624,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}`;