browser-pilot 0.0.14 → 0.0.16

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(src_exports, {
   BatchExecutor: () => BatchExecutor,
   Browser: () => Browser,
   BrowserBaseProvider: () => BrowserBaseProvider,
+  BrowserEndpointResolutionError: () => BrowserEndpointResolutionError,
   BrowserlessProvider: () => BrowserlessProvider,
   CDPError: () => CDPError,
   ElementNotFoundError: () => ElementNotFoundError,
@@ -46,12 +47,14 @@ __export(src_exports, {
   Tracer: () => Tracer,
   addBatchToPage: () => addBatchToPage,
   bufferToBase64: () => bufferToBase64,
+  buildLocalBrowserScanTargets: () => buildLocalBrowserScanTargets,
   calculateRMS: () => calculateRMS,
   connect: () => connect,
   createCDPClient: () => createCDPClient,
   createProvider: () => createProvider,
   devices: () => devices,
   disableTracing: () => disableTracing,
+  discoverLocalBrowsers: () => discoverLocalBrowsers,
   discoverTargets: () => discoverTargets,
   enableTracing: () => enableTracing,
   generateSilence: () => generateSilence,
@@ -61,8 +64,11 @@ __export(src_exports, {
   getTracer: () => getTracer,
   grantAudioPermissions: () => grantAudioPermissions,
   isTranscriptionAvailable: () => isTranscriptionAvailable,
+  parseDevToolsActivePortFile: () => parseDevToolsActivePortFile,
   parseWavHeader: () => parseWavHeader,
   pcmToWav: () => pcmToWav,
+  resolveBrowserEndpoint: () => resolveBrowserEndpoint,
+  resolveChromeUserDataDirs: () => resolveChromeUserDataDirs,
   transcribe: () => transcribe,
   validateSteps: () => validateSteps,
   waitForAnyElement: () => waitForAnyElement,
@@ -920,6 +926,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 = [
@@ -929,6 +1553,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" };
@@ -1009,6 +1688,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++) {
@@ -1018,6 +1700,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));
@@ -1041,6 +1743,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;
@@ -1078,6 +1802,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;
@@ -1093,7 +1839,8 @@ var BatchExecutor = class {
         recording,
         startTime,
         startUrl,
-        allSuccess
+        allSuccess,
+        steps
       );
     }
     return {
@@ -1108,20 +1855,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,
@@ -1177,6 +1918,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
@@ -1189,7 +1931,9 @@ var BatchExecutor = class {
         error: stepResult.error,
         screenshot: filename,
         pageUrl,
-        pageTitle
+        pageTitle,
+        stepIndex: stepResult.index,
+        actionId: `action-${stepResult.index + 1}`
       });
     } catch {
     } finally {
@@ -1201,45 +1945,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;
   }
@@ -1522,6 +2252,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 = {
@@ -1575,7 +2338,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}`);
@@ -1591,6 +2354,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);
@@ -1721,7 +2715,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: {
@@ -1852,6 +2846,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);
@@ -1875,6 +2901,7 @@ var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
   "trigger",
   "option",
   "match",
+  "where",
   "x",
   "y",
   "direction",
@@ -1884,7 +2911,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)) {
@@ -1957,6 +2990,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}`;
@@ -2241,12 +3279,12 @@ function parseWavHeader(data) {
   if (data.byteLength < 44) {
     throw new Error("Invalid WAV: file too small");
   }
-  const riff = readString(view, 0, 4);
-  const wave = readString(view, 8, 4);
+  const riff = readString2(view, 0, 4);
+  const wave = readString2(view, 8, 4);
   if (riff !== "RIFF" || wave !== "WAVE") {
     throw new Error("Invalid WAV: missing RIFF/WAVE header");
   }
-  const fmt = readString(view, 12, 4);
+  const fmt = readString2(view, 12, 4);
   if (fmt !== "fmt ") {
     throw new Error("Invalid WAV: missing fmt chunk");
   }
@@ -2255,7 +3293,7 @@ function parseWavHeader(data) {
   const bitsPerSample = view.getUint16(34, true);
   let dataOffset = 36;
   while (dataOffset < data.byteLength - 8) {
-    const chunkId = readString(view, dataOffset, 4);
+    const chunkId = readString2(view, dataOffset, 4);
     const chunkSize = view.getUint32(dataOffset + 4, true);
     if (chunkId === "data") {
       return {
@@ -2286,7 +3324,7 @@ function writeString(view, offset, str) {
     view.setUint8(offset + i, str.charCodeAt(i));
   }
 }
-function readString(view, offset, length) {
+function readString2(view, offset, length) {
   let str = "";
   for (let i = 0; i < length; i++) {
     str += String.fromCharCode(view.getUint8(offset + i));
@@ -2320,6 +3358,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() {
@@ -3756,7 +4798,8 @@ function buildCDPClient(transport, options = {}) {
         pending.delete(response.id);
         clearTimeout(request.timer);
         if (response.error) {
-          request.reject(new CDPError(response.error));
+          const error = typeof response.error === "string" ? { code: -32e3, message: response.error } : response.error;
+          request.reject(new CDPError(error));
         } else {
           request.resolve(response.result);
         }
@@ -3872,6 +4915,9 @@ function buildCDPClient(transport, options = {}) {
     get sessionId() {
       return currentSessionId;
     },
+    setSessionId(sessionId) {
+      currentSessionId = sessionId;
+    },
     get isConnected() {
       return connected;
     }
@@ -4067,6 +5113,330 @@ async function getBrowserWebSocketUrl(host = "localhost:9222") {
   return info.webSocketDebuggerUrl;
 }
 
+// src/providers/local-discovery.ts
+var CHANNEL_ORDER = ["stable", "beta", "dev", "canary"];
+var DEFAULT_PROBE_TIMEOUT_MS = 1e3;
+var DevToolsActivePortParseError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "DevToolsActivePortParseError";
+  }
+};
+function getRuntimeEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+function getRuntimePlatform() {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.platform;
+}
+function normalizePlatform(platform) {
+  if (platform === "darwin" || platform === "linux" || platform === "win32") {
+    return platform;
+  }
+  throw new Error(`Unsupported platform: ${platform ?? "unknown"}`);
+}
+function trimTrailingSeparator(path) {
+  return path.replace(/[\\/]+$/, "");
+}
+function joinPath(platform, ...parts) {
+  const separator = platform === "win32" ? "\\" : "/";
+  const cleaned = parts.map((part, index) => {
+    if (index === 0) return trimTrailingSeparator(part);
+    return part.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "");
+  }).filter((part) => part.length > 0);
+  return cleaned.join(separator);
+}
+function resolveHomeDir(platform, env, explicitHomeDir) {
+  if (explicitHomeDir) {
+    return explicitHomeDir;
+  }
+  if (platform === "win32") {
+    return env["USERPROFILE"] ?? env["HOME"] ?? "";
+  }
+  return env["HOME"] ?? env["USERPROFILE"] ?? "";
+}
+function toFileFailure(target, error) {
+  const errno = error?.code;
+  if (errno === "ENOENT") {
+    return {
+      ...target,
+      reason: "missing-file",
+      message: `DevToolsActivePort not found at ${target.portFile}`
+    };
+  }
+  return {
+    ...target,
+    reason: "unreadable-file",
+    message: error instanceof Error ? error.message : `Could not read DevToolsActivePort at ${target.portFile}`
+  };
+}
+function toProbeFailure(target, wsUrl, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lowerMessage = message.toLowerCase();
+  let reason = "connection-error";
+  if (lowerMessage.includes("refused") || lowerMessage.includes("econnrefused")) {
+    reason = "connection-refused";
+  } else if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    reason = "connection-timeout";
+  } else if (lowerMessage.includes("closed")) {
+    reason = "unexpected-close";
+  } else if (lowerMessage.includes("browser.getversion") || lowerMessage.includes("cdp") || lowerMessage.includes("protocol")) {
+    reason = "cdp-error";
+  }
+  return {
+    ...target,
+    wsUrl,
+    reason,
+    message
+  };
+}
+async function readTextFile(path) {
+  const fs2 = await import("fs/promises");
+  return fs2.readFile(path, "utf-8");
+}
+async function probeBrowserWebSocket(wsUrl, timeoutMs) {
+  let client;
+  try {
+    client = await createCDPClient(wsUrl, { timeout: timeoutMs });
+    const version = await client.send("Browser.getVersion", void 0, null);
+    return { browserVersion: version.product };
+  } finally {
+    await client?.close().catch(() => {
+    });
+  }
+}
+var defaultDependencies = {
+  readTextFile,
+  probeBrowserWebSocket,
+  getLegacyBrowserWebSocketUrl: getBrowserWebSocketUrl
+};
+function resolveChromeUserDataDirs(options = {}) {
+  const env = options.env ?? getRuntimeEnv();
+  const platform = normalizePlatform(options.platform ?? getRuntimePlatform());
+  const homeDir = resolveHomeDir(platform, env, options.homeDir);
+  if (!homeDir) {
+    throw new Error("Could not determine home directory for local Chrome discovery");
+  }
+  switch (platform) {
+    case "darwin": {
+      const base = joinPath(platform, homeDir, "Library", "Application Support", "Google");
+      return {
+        stable: joinPath(platform, base, "Chrome"),
+        beta: joinPath(platform, base, "Chrome Beta"),
+        dev: joinPath(platform, base, "Chrome Dev"),
+        canary: joinPath(platform, base, "Chrome Canary")
+      };
+    }
+    case "linux": {
+      const configHome = env["CHROME_CONFIG_HOME"] ?? env["XDG_CONFIG_HOME"] ?? joinPath(platform, homeDir, ".config");
+      return {
+        stable: joinPath(platform, configHome, "google-chrome"),
+        beta: joinPath(platform, configHome, "google-chrome-beta"),
+        dev: joinPath(platform, configHome, "google-chrome-dev"),
+        canary: joinPath(platform, configHome, "google-chrome-canary")
+      };
+    }
+    case "win32": {
+      const localAppData = env["LOCALAPPDATA"] ?? joinPath(platform, homeDir, "AppData", "Local");
+      const base = joinPath(platform, localAppData, "Google");
+      return {
+        stable: joinPath(platform, base, "Chrome", "User Data"),
+        beta: joinPath(platform, base, "Chrome Beta", "User Data"),
+        dev: joinPath(platform, base, "Chrome Dev", "User Data"),
+        canary: joinPath(platform, base, "Chrome SxS", "User Data")
+      };
+    }
+  }
+  throw new Error(`Unsupported platform for local Chrome discovery: ${platform}`);
+}
+function buildLocalBrowserScanTargets(options = {}) {
+  const env = options.env ?? getRuntimeEnv();
+  const platform = normalizePlatform(options.platform ?? getRuntimePlatform());
+  if (options.userDataDir) {
+    return [
+      {
+        channel: options.channel ?? "custom",
+        userDataDir: options.userDataDir,
+        portFile: joinPath(platform, options.userDataDir, "DevToolsActivePort")
+      }
+    ];
+  }
+  const dirs = resolveChromeUserDataDirs({
+    platform,
+    env,
+    homeDir: options.homeDir
+  });
+  const channels = options.channel ? [options.channel] : CHANNEL_ORDER;
+  return channels.map((channel) => ({
+    channel,
+    userDataDir: dirs[channel],
+    portFile: joinPath(platform, dirs[channel], "DevToolsActivePort")
+  }));
+}
+function parseDevToolsActivePortFile(content) {
+  const lines = content.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length !== 2) {
+    throw new DevToolsActivePortParseError(
+      `Expected exactly 2 non-empty lines in DevToolsActivePort, got ${lines.length}`,
+      "malformed-file"
+    );
+  }
+  const portText = lines[0];
+  const browserPath = lines[1];
+  const port = Number.parseInt(portText, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new DevToolsActivePortParseError(
+      `Invalid DevToolsActivePort port: ${portText}`,
+      "invalid-port"
+    );
+  }
+  if (!browserPath.startsWith("/devtools/browser/") || browserPath.includes("..") || /[?#\s\\]/u.test(browserPath)) {
+    throw new DevToolsActivePortParseError(
+      `Invalid DevToolsActivePort browser path: ${browserPath}`,
+      "invalid-path"
+    );
+  }
+  return {
+    port,
+    browserPath,
+    wsUrl: `ws://127.0.0.1:${port}${browserPath}`
+  };
+}
+async function inspectScanTarget(target, options, deps) {
+  let content;
+  try {
+    content = await deps.readTextFile(target.portFile);
+  } catch (error) {
+    return { kind: "failure", failure: toFileFailure(target, error) };
+  }
+  let parsed;
+  try {
+    parsed = parseDevToolsActivePortFile(content);
+  } catch (error) {
+    if (error instanceof DevToolsActivePortParseError) {
+      return {
+        kind: "failure",
+        failure: {
+          ...target,
+          reason: error.reason,
+          message: error.message
+        }
+      };
+    }
+    throw error;
+  }
+  try {
+    const probe = await deps.probeBrowserWebSocket(
+      parsed.wsUrl,
+      options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS
+    );
+    return {
+      kind: "candidate",
+      candidate: {
+        ...target,
+        port: parsed.port,
+        browserPath: parsed.browserPath,
+        wsUrl: parsed.wsUrl,
+        browserVersion: probe.browserVersion
+      }
+    };
+  } catch (error) {
+    return {
+      kind: "failure",
+      failure: toProbeFailure(target, parsed.wsUrl, error)
+    };
+  }
+}
+async function discoverLocalBrowsers(options = {}, deps = defaultDependencies) {
+  const scanTargets = buildLocalBrowserScanTargets(options);
+  const outcomes = await Promise.all(
+    scanTargets.map((target) => inspectScanTarget(target, options, deps))
+  );
+  const candidates = [];
+  const failures = [];
+  for (const outcome of outcomes) {
+    if (outcome.kind === "candidate") {
+      candidates.push(outcome.candidate);
+    } else {
+      failures.push(outcome.failure);
+    }
+  }
+  return { candidates, failures };
+}
+var BrowserEndpointResolutionError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+  name = "BrowserEndpointResolutionError";
+};
+async function resolveBrowserEndpoint(options = {}, deps = defaultDependencies) {
+  if (options.explicitWsUrl) {
+    return {
+      wsUrl: options.explicitWsUrl,
+      source: "explicit-ws"
+    };
+  }
+  let localDiscovery;
+  if (options.allowLocalDiscovery ?? true) {
+    localDiscovery = await discoverLocalBrowsers(options, deps);
+    if (localDiscovery.candidates.length === 1) {
+      const candidate = localDiscovery.candidates[0];
+      return {
+        wsUrl: candidate.wsUrl,
+        source: "devtools-active-port",
+        channel: candidate.channel,
+        userDataDir: candidate.userDataDir
+      };
+    }
+    if (localDiscovery.candidates.length > 1) {
+      throw new BrowserEndpointResolutionError(
+        "multiple-local-browsers",
+        "Multiple local Chrome profiles are available for auto-discovery",
+        {
+          candidates: localDiscovery.candidates,
+          failures: localDiscovery.failures
+        }
+      );
+    }
+  }
+  if (options.allowLegacyHostFallback ?? true) {
+    const legacyHost = options.legacyHost ?? "localhost:9222";
+    try {
+      return {
+        wsUrl: await deps.getLegacyBrowserWebSocketUrl(legacyHost),
+        source: "json-version"
+      };
+    } catch (error) {
+      throw new BrowserEndpointResolutionError(
+        "browser-not-found",
+        "Could not resolve a browser endpoint",
+        {
+          candidates: localDiscovery?.candidates,
+          failures: localDiscovery?.failures,
+          legacyError: error instanceof Error ? error : new Error(String(error)),
+          legacyHost
+        }
+      );
+    }
+  }
+  throw new BrowserEndpointResolutionError(
+    "browser-not-found",
+    "Could not resolve a browser endpoint",
+    {
+      candidates: localDiscovery?.candidates,
+      failures: localDiscovery?.failures
+    }
+  );
+}
+
 // src/providers/index.ts
 function createProvider(options) {
   switch (options.provider) {
@@ -8161,13 +9531,26 @@ var Browser = class _Browser {
    * Connect to a browser instance
    */
   static async connect(options) {
-    const provider = createProvider(options);
-    const session = await provider.createSession(options.session);
+    let connectOptions = options;
+    if (options.provider === "generic" && !options.wsUrl) {
+      const endpoint = await resolveBrowserEndpoint({
+        channel: options.channel,
+        userDataDir: options.userDataDir,
+        allowLocalDiscovery: true,
+        allowLegacyHostFallback: true
+      });
+      connectOptions = {
+        ...options,
+        wsUrl: endpoint.wsUrl
+      };
+    }
+    const provider = createProvider(connectOptions);
+    const session = await provider.createSession(connectOptions.session);
     const cdp = await createCDPClient(session.wsUrl, {
-      debug: options.debug,
-      timeout: options.timeout
+      debug: connectOptions.debug,
+      timeout: connectOptions.timeout
     });
-    return new _Browser(cdp, provider, session, options);
+    return new _Browser(cdp, provider, session, connectOptions);
   }
   /**
    * Get or create a page by name.
@@ -8573,6 +9956,7 @@ function disableTracing() {
   BatchExecutor,
   Browser,
   BrowserBaseProvider,
+  BrowserEndpointResolutionError,
   BrowserlessProvider,
   CDPError,
   ElementNotFoundError,
@@ -8584,12 +9968,14 @@ function disableTracing() {
   Tracer,
   addBatchToPage,
   bufferToBase64,
+  buildLocalBrowserScanTargets,
   calculateRMS,
   connect,
   createCDPClient,
   createProvider,
   devices,
   disableTracing,
+  discoverLocalBrowsers,
   discoverTargets,
   enableTracing,
   generateSilence,
@@ -8599,8 +9985,11 @@ function disableTracing() {
   getTracer,
   grantAudioPermissions,
   isTranscriptionAvailable,
+  parseDevToolsActivePortFile,
   parseWavHeader,
   pcmToWav,
+  resolveBrowserEndpoint,
+  resolveChromeUserDataDirs,
   transcribe,
   validateSteps,
   waitForAnyElement,