@opensteer/browser-core 0.7.0

package/dist/index.js

@@ -0,0 +1,2846 @@
+// src/brand.ts
+function brand(value) {
+  return value;
+}
+
+// src/identity.ts
+function normalizeRef(prefix, value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new TypeError(`${prefix} reference cannot be empty`);
+  }
+  const canonicalPrefix = `${prefix}:`;
+  if (trimmed.startsWith(canonicalPrefix)) {
+    if (trimmed.length === canonicalPrefix.length) {
+      throw new TypeError(`${prefix} reference must include an identifier`);
+    }
+    return trimmed;
+  }
+  if (trimmed.includes(":")) {
+    throw new TypeError(
+      `${prefix} reference "${trimmed}" must either omit a prefix or use ${canonicalPrefix}`
+    );
+  }
+  return `${canonicalPrefix}${trimmed}`;
+}
+function hasPrefix(prefix, value) {
+  return value.startsWith(`${prefix}:`) && value.length > prefix.length + 1;
+}
+function createStringRef(prefix, value) {
+  return brand(normalizeRef(prefix, value));
+}
+function createSessionRef(value) {
+  return createStringRef("session", value);
+}
+function createPageRef(value) {
+  return createStringRef("page", value);
+}
+function createFrameRef(value) {
+  return createStringRef("frame", value);
+}
+function createDocumentRef(value) {
+  return createStringRef("document", value);
+}
+function createNodeRef(value) {
+  return createStringRef("node", value);
+}
+function createNetworkRequestId(value) {
+  return createStringRef("request", value);
+}
+function createDownloadRef(value) {
+  return createStringRef("download", value);
+}
+function createDialogRef(value) {
+  return createStringRef("dialog", value);
+}
+function createChooserRef(value) {
+  return createStringRef("chooser", value);
+}
+function createWorkerRef(value) {
+  return createStringRef("worker", value);
+}
+function isSessionRef(value) {
+  return hasPrefix("session", value);
+}
+function isPageRef(value) {
+  return hasPrefix("page", value);
+}
+function isFrameRef(value) {
+  return hasPrefix("frame", value);
+}
+function isDocumentRef(value) {
+  return hasPrefix("document", value);
+}
+function isNodeRef(value) {
+  return hasPrefix("node", value);
+}
+function isNetworkRequestId(value) {
+  return hasPrefix("request", value);
+}
+function isDownloadRef(value) {
+  return hasPrefix("download", value);
+}
+function isDialogRef(value) {
+  return hasPrefix("dialog", value);
+}
+function isChooserRef(value) {
+  return hasPrefix("chooser", value);
+}
+function isWorkerRef(value) {
+  return hasPrefix("worker", value);
+}
+function serializeRef(ref) {
+  return ref;
+}
+function createDocumentEpoch(value) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new RangeError(
+      `document epoch must be a non-negative integer, received ${String(value)}`
+    );
+  }
+  return brand(value);
+}
+function nextDocumentEpoch(epoch) {
+  return createDocumentEpoch(epoch + 1);
+}
+function serializeDocumentEpoch(epoch) {
+  return epoch;
+}
+function createNodeLocator(documentRef, documentEpoch, nodeRef) {
+  return { documentRef, documentEpoch, nodeRef };
+}
+
+// src/geometry.ts
+function assertFinite(value, name) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`${name} must be a finite number`);
+  }
+}
+function assertNonNegative(value, name) {
+  assertFinite(value, name);
+  if (value < 0) {
+    throw new RangeError(`${name} must be greater than or equal to 0`);
+  }
+}
+function createScale(value, name) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new RangeError(`${name} must be greater than 0`);
+  }
+  return brand(value);
+}
+function createPoint(x, y) {
+  assertFinite(x, "point.x");
+  assertFinite(y, "point.y");
+  return { x, y };
+}
+function createSize(width, height) {
+  assertNonNegative(width, "size.width");
+  assertNonNegative(height, "size.height");
+  return { width, height };
+}
+function createRect(x, y, width, height) {
+  assertFinite(x, "rect.x");
+  assertFinite(y, "rect.y");
+  assertNonNegative(width, "rect.width");
+  assertNonNegative(height, "rect.height");
+  return { x, y, width, height };
+}
+function createScrollOffset(x, y) {
+  assertFinite(x, "scrollOffset.x");
+  assertFinite(y, "scrollOffset.y");
+  return { x, y };
+}
+function createQuad(points) {
+  return points;
+}
+function rectToQuad(rect) {
+  return createQuad([
+    createPoint(rect.x, rect.y),
+    createPoint(rect.x + rect.width, rect.y),
+    createPoint(rect.x + rect.width, rect.y + rect.height),
+    createPoint(rect.x, rect.y + rect.height)
+  ]);
+}
+function quadBounds(quad) {
+  const xs = quad.map((point) => point.x);
+  const ys = quad.map((point) => point.y);
+  const minX = Math.min(...xs);
+  const maxX = Math.max(...xs);
+  const minY = Math.min(...ys);
+  const maxY = Math.max(...ys);
+  return createRect(minX, minY, maxX - minX, maxY - minY);
+}
+function rectContainsPoint(rect, point) {
+  return point.x >= rect.x && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height;
+}
+function createDevicePixelRatio(value) {
+  return createScale(value, "devicePixelRatio");
+}
+function createPageScaleFactor(value) {
+  return createScale(value, "pageScaleFactor");
+}
+function createPageZoomFactor(value) {
+  return createScale(value, "pageZoomFactor");
+}
+
+// src/network.ts
+function createHeaderEntry(name, value) {
+  return { name, value };
+}
+function createBodyPayload(bytes, options = {}) {
+  return {
+    bytes,
+    encoding: options.encoding ?? "identity",
+    truncated: options.truncated ?? false,
+    capturedByteLength: bytes.byteLength,
+    ...options.mimeType === void 0 ? {} : { mimeType: options.mimeType },
+    ...options.charset === void 0 ? {} : { charset: options.charset },
+    ...options.originalByteLength === void 0 ? {} : { originalByteLength: options.originalByteLength }
+  };
+}
+function bodyPayloadFromUtf8(value, options = {}) {
+  return createBodyPayload(new TextEncoder().encode(value), {
+    ...options.mimeType === void 0 ? {} : { mimeType: options.mimeType },
+    ...options.encoding === void 0 ? {} : { encoding: options.encoding },
+    ...options.truncated === void 0 ? {} : { truncated: options.truncated },
+    ...options.originalByteLength === void 0 ? {} : { originalByteLength: options.originalByteLength },
+    charset: "utf-8"
+  });
+}
+function matchesNetworkRecordFilters(record, filters) {
+  if (filters.url !== void 0 && !includesCaseInsensitive(record.url, filters.url)) {
+    return false;
+  }
+  let parsedUrl;
+  const getParsedUrl = () => {
+    parsedUrl ??= new URL(record.url);
+    return parsedUrl;
+  };
+  if (filters.hostname !== void 0) {
+    const hostname = getParsedUrl().hostname;
+    if (!includesCaseInsensitive(hostname, filters.hostname)) {
+      return false;
+    }
+  }
+  if (filters.path !== void 0) {
+    const path = getParsedUrl().pathname;
+    if (!includesCaseInsensitive(path, filters.path)) {
+      return false;
+    }
+  }
+  if (filters.method !== void 0 && !includesCaseInsensitive(record.method, filters.method)) {
+    return false;
+  }
+  if (filters.status !== void 0 && !includesCaseInsensitive(
+    record.status === void 0 ? "" : String(record.status),
+    filters.status
+  )) {
+    return false;
+  }
+  if (filters.resourceType !== void 0 && record.resourceType !== filters.resourceType) {
+    return false;
+  }
+  return true;
+}
+function includesCaseInsensitive(value, query) {
+  return value.toLowerCase().includes(query.toLowerCase());
+}
+
+// src/snapshots.ts
+function findDomSnapshotNode(snapshot, snapshotNodeId) {
+  return snapshot.nodes.find((node) => node.snapshotNodeId === snapshotNodeId);
+}
+function findDomSnapshotNodeByRef(snapshot, nodeRef) {
+  return snapshot.nodes.find((node) => node.nodeRef === nodeRef);
+}
+
+// src/storage.ts
+function parseUrl(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return null;
+  }
+}
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname.endsWith(".localhost");
+}
+function normalizeCookiePath(path) {
+  if (path.length === 0) {
+    return "/";
+  }
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function pathMatchesCookiePath(requestPath, cookiePath) {
+  const normalizedRequestPath = requestPath.length === 0 ? "/" : requestPath;
+  const normalizedCookiePath = normalizeCookiePath(cookiePath);
+  if (normalizedRequestPath === normalizedCookiePath) {
+    return true;
+  }
+  if (!normalizedRequestPath.startsWith(normalizedCookiePath)) {
+    return false;
+  }
+  if (normalizedCookiePath.endsWith("/")) {
+    return true;
+  }
+  return normalizedRequestPath.charAt(normalizedCookiePath.length) === "/";
+}
+function filterCookieRecords(cookies, urls) {
+  const parsed = urls.map(parseUrl).filter((url) => url !== null);
+  if (parsed.length === 0) {
+    return [...cookies];
+  }
+  return cookies.filter((cookie) => {
+    return parsed.some((url) => {
+      let domain = cookie.domain;
+      if (!domain.startsWith(".")) {
+        domain = `.${domain}`;
+      }
+      if (!`.${url.hostname}`.endsWith(domain)) {
+        return false;
+      }
+      if (!pathMatchesCookiePath(url.pathname, cookie.path)) {
+        return false;
+      }
+      if (url.protocol !== "https:" && !isLocalHostname(url.hostname) && cookie.secure) {
+        return false;
+      }
+      return true;
+    });
+  });
+}
+
+// src/capabilities.ts
+function noBrowserCapabilities() {
+  return {
+    executor: {
+      sessionLifecycle: false,
+      pageLifecycle: false,
+      navigation: false,
+      pointerInput: false,
+      keyboardInput: false,
+      touchInput: false,
+      screenshots: false,
+      executionControl: {
+        pause: false,
+        resume: false,
+        freeze: false
+      }
+    },
+    inspector: {
+      pageEnumeration: false,
+      frameEnumeration: false,
+      html: false,
+      domSnapshot: false,
+      visualStability: false,
+      text: false,
+      attributes: false,
+      hitTest: false,
+      viewportMetrics: false,
+      network: false,
+      networkBodies: false,
+      cookies: false,
+      localStorage: false,
+      sessionStorage: false,
+      indexedDb: false
+    },
+    transport: {
+      sessionHttp: false
+    },
+    instrumentation: {
+      initScripts: false,
+      routing: false
+    },
+    events: {
+      pageLifecycle: false,
+      dialog: false,
+      download: false,
+      chooser: false,
+      worker: false,
+      console: false,
+      pageError: false,
+      websocket: false,
+      eventStream: false,
+      executionState: false
+    }
+  };
+}
+function allBrowserCapabilities() {
+  return mergeBrowserCapabilities(noBrowserCapabilities(), {
+    executor: {
+      sessionLifecycle: true,
+      pageLifecycle: true,
+      navigation: true,
+      pointerInput: true,
+      keyboardInput: true,
+      touchInput: true,
+      screenshots: true,
+      executionControl: {
+        pause: true,
+        resume: true,
+        freeze: true
+      }
+    },
+    inspector: {
+      pageEnumeration: true,
+      frameEnumeration: true,
+      html: true,
+      domSnapshot: true,
+      visualStability: true,
+      text: true,
+      attributes: true,
+      hitTest: true,
+      viewportMetrics: true,
+      network: true,
+      networkBodies: true,
+      cookies: true,
+      localStorage: true,
+      sessionStorage: true,
+      indexedDb: true
+    },
+    transport: {
+      sessionHttp: true
+    },
+    instrumentation: {
+      initScripts: true,
+      routing: true
+    },
+    events: {
+      pageLifecycle: true,
+      dialog: true,
+      download: true,
+      chooser: true,
+      worker: true,
+      console: true,
+      pageError: true,
+      websocket: true,
+      eventStream: true,
+      executionState: true
+    }
+  });
+}
+function mergeBrowserCapabilities(base, override) {
+  return {
+    executor: {
+      ...base.executor,
+      ...override.executor,
+      executionControl: {
+        ...base.executor.executionControl,
+        ...override.executor?.executionControl
+      }
+    },
+    inspector: {
+      ...base.inspector,
+      ...override.inspector
+    },
+    transport: {
+      ...base.transport,
+      ...override.transport
+    },
+    instrumentation: {
+      ...base.instrumentation,
+      ...override.instrumentation
+    },
+    events: {
+      ...base.events,
+      ...override.events
+    }
+  };
+}
+function hasCapability(capabilities, path) {
+  switch (path) {
+    case "executor.sessionLifecycle":
+      return capabilities.executor.sessionLifecycle;
+    case "executor.pageLifecycle":
+      return capabilities.executor.pageLifecycle;
+    case "executor.navigation":
+      return capabilities.executor.navigation;
+    case "executor.pointerInput":
+      return capabilities.executor.pointerInput;
+    case "executor.keyboardInput":
+      return capabilities.executor.keyboardInput;
+    case "executor.touchInput":
+      return capabilities.executor.touchInput;
+    case "executor.screenshots":
+      return capabilities.executor.screenshots;
+    case "executor.executionControl.pause":
+      return capabilities.executor.executionControl.pause;
+    case "executor.executionControl.resume":
+      return capabilities.executor.executionControl.resume;
+    case "executor.executionControl.freeze":
+      return capabilities.executor.executionControl.freeze;
+    case "inspector.pageEnumeration":
+      return capabilities.inspector.pageEnumeration;
+    case "inspector.frameEnumeration":
+      return capabilities.inspector.frameEnumeration;
+    case "inspector.html":
+      return capabilities.inspector.html;
+    case "inspector.domSnapshot":
+      return capabilities.inspector.domSnapshot;
+    case "inspector.visualStability":
+      return capabilities.inspector.visualStability;
+    case "inspector.text":
+      return capabilities.inspector.text;
+    case "inspector.attributes":
+      return capabilities.inspector.attributes;
+    case "inspector.hitTest":
+      return capabilities.inspector.hitTest;
+    case "inspector.viewportMetrics":
+      return capabilities.inspector.viewportMetrics;
+    case "inspector.network":
+      return capabilities.inspector.network;
+    case "inspector.networkBodies":
+      return capabilities.inspector.networkBodies;
+    case "inspector.cookies":
+      return capabilities.inspector.cookies;
+    case "inspector.localStorage":
+      return capabilities.inspector.localStorage;
+    case "inspector.sessionStorage":
+      return capabilities.inspector.sessionStorage;
+    case "inspector.indexedDb":
+      return capabilities.inspector.indexedDb;
+    case "transport.sessionHttp":
+      return capabilities.transport.sessionHttp;
+    case "instrumentation.initScripts":
+      return capabilities.instrumentation.initScripts;
+    case "instrumentation.routing":
+      return capabilities.instrumentation.routing;
+    case "events.pageLifecycle":
+      return capabilities.events.pageLifecycle;
+    case "events.dialog":
+      return capabilities.events.dialog;
+    case "events.download":
+      return capabilities.events.download;
+    case "events.chooser":
+      return capabilities.events.chooser;
+    case "events.worker":
+      return capabilities.events.worker;
+    case "events.console":
+      return capabilities.events.console;
+    case "events.pageError":
+      return capabilities.events.pageError;
+    case "events.websocket":
+      return capabilities.events.websocket;
+    case "events.eventStream":
+      return capabilities.events.eventStream;
+    case "events.executionState":
+      return capabilities.events.executionState;
+  }
+}
+
+// src/errors.ts
+var BrowserCoreError = class extends Error {
+  code;
+  retriable;
+  capability;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "BrowserCoreError";
+    this.code = code;
+    this.retriable = options.retriable ?? false;
+    this.capability = options.capability;
+    this.details = options.details;
+  }
+};
+function isBrowserCoreError(value) {
+  return value instanceof BrowserCoreError;
+}
+function createBrowserCoreError(code, message, options = {}) {
+  return new BrowserCoreError(code, message, options);
+}
+function unsupportedCapabilityError(capability) {
+  return new BrowserCoreError(
+    "unsupported-capability",
+    `capability ${capability} is not supported by this backend`,
+    {
+      capability,
+      details: { capability }
+    }
+  );
+}
+function staleNodeRefError(input) {
+  return new BrowserCoreError(
+    "stale-node-ref",
+    `node ${input.nodeRef} is stale for ${input.documentRef} at epoch ${input.documentEpoch}`,
+    {
+      details: {
+        nodeRef: input.nodeRef,
+        documentRef: input.documentRef,
+        documentEpoch: input.documentEpoch
+      }
+    }
+  );
+}
+function closedSessionError(sessionRef) {
+  return new BrowserCoreError("session-closed", `session ${sessionRef} is closed`, {
+    details: { sessionRef }
+  });
+}
+function closedPageError(pageRef) {
+  return new BrowserCoreError("page-closed", `page ${pageRef} is closed`, {
+    details: { pageRef }
+  });
+}
+
+// src/fake-engine.ts
+function clone(value) {
+  return structuredClone(value);
+}
+function titleFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname.length === 0) {
+      return url;
+    }
+    return parsed.hostname;
+  } catch {
+    return url;
+  }
+}
+function buildTransportKey(request) {
+  return `${request.method.toUpperCase()} ${request.url}`;
+}
+function stripFragment(url) {
+  const hashIndex = url.indexOf("#");
+  return hashIndex === -1 ? url : url.slice(0, hashIndex);
+}
+function originFromUrl(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return void 0;
+  }
+}
+var FakeBrowserCoreEngine = class {
+  capabilities;
+  sessions = /* @__PURE__ */ new Map();
+  pages = /* @__PURE__ */ new Map();
+  frames = /* @__PURE__ */ new Map();
+  documents = /* @__PURE__ */ new Map();
+  retiredDocuments = /* @__PURE__ */ new Set();
+  pageCounter = 0;
+  frameCounter = 0;
+  documentCounter = 0;
+  nodeCounter = 0;
+  requestCounter = 0;
+  sessionCounter = 0;
+  stepCounter = 0;
+  eventCounter = 0;
+  timestampMs;
+  constructor(options = {}) {
+    this.capabilities = options.capabilities ?? allBrowserCapabilities();
+    this.timestampMs = options.timestampSeedMs ?? 17e11;
+    if (options.initialPages && options.initialPages.length > 0) {
+      const sessionRef = createSessionRef(`seed-${++this.sessionCounter}`);
+      const storage = this.createDefaultStorage(sessionRef);
+      this.sessions.set(sessionRef, {
+        sessionRef,
+        pageRefs: /* @__PURE__ */ new Set(),
+        cookies: [],
+        storage,
+        transportResponses: /* @__PURE__ */ new Map()
+      });
+      for (const page of options.initialPages) {
+        void this.createPageInternal(sessionRef, {
+          ...page.url === void 0 ? {} : { url: page.url },
+          ...page.title === void 0 ? {} : { title: page.title },
+          ...page.viewportSize === void 0 ? {} : { viewportSize: page.viewportSize }
+        });
+      }
+    }
+  }
+  enqueueStepEvents(pageRef, events) {
+    const page = this.requirePage(pageRef);
+    for (const event of events) {
+      this.assertEventCapability(event.kind);
+      page.queuedEvents.push(clone(event));
+    }
+  }
+  advanceDocumentEpoch(documentRef) {
+    const document = this.requireDocument(documentRef);
+    const nextEpoch = nextDocumentEpoch(document.documentEpoch);
+    this.rebuildDocumentState(documentRef, {
+      documentRef,
+      documentEpoch: nextEpoch,
+      url: document.url,
+      title: titleFromUrl(document.url)
+    });
+    return nextEpoch;
+  }
+  seedCookies(sessionRef, cookies) {
+    const session = this.requireSession(sessionRef);
+    session.cookies = cookies.map((cookie) => clone(cookie));
+  }
+  seedTransportResponse(sessionRef, request, response) {
+    const session = this.requireSession(sessionRef);
+    session.transportResponses.set(buildTransportKey(request), clone(response));
+  }
+  async addInitScript(input) {
+    if (!hasCapability(this.capabilities, "instrumentation.initScripts")) {
+      throw unsupportedCapabilityError("instrumentation.initScripts");
+    }
+    this.requireSession(input.sessionRef);
+    return {
+      registrationId: `fake-init-script-${String(++this.stepCounter)}`,
+      sessionRef: input.sessionRef,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef }
+    };
+  }
+  async registerRoute(input) {
+    if (!hasCapability(this.capabilities, "instrumentation.routing")) {
+      throw unsupportedCapabilityError("instrumentation.routing");
+    }
+    this.requireSession(input.sessionRef);
+    return {
+      routeId: `fake-route-${String(++this.stepCounter)}`,
+      sessionRef: input.sessionRef,
+      ...input.pageRef === void 0 ? {} : { pageRef: input.pageRef },
+      urlPattern: input.urlPattern
+    };
+  }
+  async createSession() {
+    this.requireCapability("executor.sessionLifecycle");
+    const sessionRef = createSessionRef(`fake-${++this.sessionCounter}`);
+    this.sessions.set(sessionRef, {
+      sessionRef,
+      pageRefs: /* @__PURE__ */ new Set(),
+      cookies: [],
+      storage: this.createDefaultStorage(sessionRef),
+      transportResponses: /* @__PURE__ */ new Map()
+    });
+    return sessionRef;
+  }
+  async closeSession(input) {
+    this.requireCapability("executor.sessionLifecycle");
+    const session = this.requireSession(input.sessionRef);
+    for (const pageRef of session.pageRefs) {
+      this.destroyPage(pageRef);
+    }
+    this.sessions.delete(input.sessionRef);
+  }
+  async createPage(input) {
+    this.requireCapability("executor.pageLifecycle");
+    const session = this.requireSession(input.sessionRef);
+    const page = this.createPageInternal(session.sessionRef, {
+      ...input.openerPageRef === void 0 ? {} : { openerPageRef: input.openerPageRef },
+      ...input.url === void 0 ? {} : { url: input.url }
+    });
+    const events = [];
+    const pageCreatedEvent = this.maybeCreateEvent({
+      kind: "page-created",
+      sessionRef: session.sessionRef,
+      pageRef: page.pageInfo.pageRef
+    });
+    if (pageCreatedEvent) {
+      events.push(pageCreatedEvent);
+    }
+    if (input.openerPageRef) {
+      const popupOpenedEvent = this.maybeCreateEvent({
+        kind: "popup-opened",
+        sessionRef: session.sessionRef,
+        pageRef: page.pageInfo.pageRef,
+        openerPageRef: input.openerPageRef
+      });
+      if (popupOpenedEvent) {
+        events.push(popupOpenedEvent);
+      }
+    }
+    return this.createStepResult(session.sessionRef, page.pageInfo.pageRef, {
+      frameRef: page.frameInfo.frameRef,
+      documentRef: page.frameInfo.documentRef,
+      documentEpoch: page.frameInfo.documentEpoch,
+      events,
+      data: clone(page.pageInfo)
+    });
+  }
+  async closePage(input) {
+    this.requireCapability("executor.pageLifecycle");
+    const page = this.requirePage(input.pageRef);
+    const frameInfo = this.getMainFrameInfo(page.pageRef);
+    const sessionRef = page.sessionRef;
+    this.destroyPage(page.pageRef);
+    const pageClosedEvent = this.maybeCreateEvent({
+      kind: "page-closed",
+      sessionRef,
+      pageRef: page.pageRef
+    });
+    return this.createStepResult(sessionRef, page.pageRef, {
+      frameRef: frameInfo.frameRef,
+      documentRef: frameInfo.documentRef,
+      documentEpoch: frameInfo.documentEpoch,
+      events: pageClosedEvent ? [pageClosedEvent] : [],
+      data: void 0
+    });
+  }
+  async activatePage(input) {
+    this.requireCapability("executor.pageLifecycle");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: clone(this.pageInfoFromState(page))
+    });
+  }
+  async navigate(input) {
+    return this.performNavigation(input.pageRef, input.url, {
+      forceNewDocument: false,
+      recordHistory: true,
+      ...input.referrer === void 0 ? {} : { referrer: input.referrer }
+    });
+  }
+  async reload(input) {
+    const page = this.requirePage(input.pageRef);
+    const pageInfo = this.pageInfoFromState(page);
+    return this.performNavigation(input.pageRef, pageInfo.url, {
+      forceNewDocument: true,
+      recordHistory: false
+    });
+  }
+  async goBack(input) {
+    this.requireCapability("executor.navigation");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    if (page.historyIndex === 0) {
+      return this.createStepResult(page.sessionRef, page.pageRef, {
+        frameRef: mainFrame.frameRef,
+        documentRef: mainFrame.documentRef,
+        documentEpoch: mainFrame.documentEpoch,
+        events: this.drainQueuedEvents(page.pageRef),
+        data: false
+      });
+    }
+    page.historyIndex -= 1;
+    const url = page.history[page.historyIndex];
+    const result = await this.performNavigation(input.pageRef, url, {
+      forceNewDocument: false,
+      recordHistory: false
+    });
+    return {
+      ...result,
+      data: true
+    };
+  }
+  async goForward(input) {
+    this.requireCapability("executor.navigation");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    if (page.historyIndex >= page.history.length - 1) {
+      return this.createStepResult(page.sessionRef, page.pageRef, {
+        frameRef: mainFrame.frameRef,
+        documentRef: mainFrame.documentRef,
+        documentEpoch: mainFrame.documentEpoch,
+        events: this.drainQueuedEvents(page.pageRef),
+        data: false
+      });
+    }
+    page.historyIndex += 1;
+    const url = page.history[page.historyIndex];
+    const result = await this.performNavigation(input.pageRef, url, {
+      forceNewDocument: false,
+      recordHistory: false
+    });
+    return {
+      ...result,
+      data: true
+    };
+  }
+  async stopLoading(input) {
+    this.requireCapability("executor.navigation");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: void 0
+    });
+  }
+  async mouseMove(input) {
+    this.requireCapability("executor.pointerInput");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: void 0
+    });
+  }
+  async mouseClick(input) {
+    this.requireCapability("executor.pointerInput");
+    const page = this.requirePage(input.pageRef);
+    const hitTest = await this.hitTest({
+      pageRef: input.pageRef,
+      point: input.point,
+      coordinateSpace: input.coordinateSpace
+    });
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: hitTest
+    });
+  }
+  async mouseScroll(input) {
+    this.requireCapability("executor.pointerInput");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrame(page.pageRef);
+    const nextScroll = createScrollOffset(
+      page.viewportMetrics.scrollOffset.x + input.delta.x,
+      page.viewportMetrics.scrollOffset.y + input.delta.y
+    );
+    page.viewportMetrics = {
+      ...page.viewportMetrics,
+      scrollOffset: nextScroll,
+      layoutViewport: {
+        ...page.viewportMetrics.layoutViewport,
+        origin: createPoint(nextScroll.x, nextScroll.y)
+      },
+      visualViewport: {
+        ...page.viewportMetrics.visualViewport,
+        origin: createPoint(nextScroll.x, nextScroll.y)
+      }
+    };
+    this.rebuildDocumentState(mainFrame.frameInfo.documentRef, {
+      documentRef: mainFrame.frameInfo.documentRef,
+      documentEpoch: mainFrame.frameInfo.documentEpoch,
+      url: mainFrame.frameInfo.url,
+      title: titleFromUrl(mainFrame.frameInfo.url)
+    });
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameInfo.frameRef,
+      documentRef: mainFrame.frameInfo.documentRef,
+      documentEpoch: mainFrame.frameInfo.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: void 0
+    });
+  }
+  async keyPress(input) {
+    this.requireCapability("executor.keyboardInput");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: void 0
+    });
+  }
+  async textInput(input) {
+    this.requireCapability("executor.keyboardInput");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: void 0
+    });
+  }
+  async captureScreenshot(input) {
+    this.requireCapability("executor.screenshots");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    const targetSize = input.fullPage ? page.viewportMetrics.contentSize : page.viewportMetrics.visualViewport.size;
+    const payload = bodyPayloadFromUtf8(
+      JSON.stringify({
+        pageRef: page.pageRef,
+        url: mainFrame.url,
+        format: input.format ?? "webp",
+        includeCursor: input.includeCursor ?? false
+      }),
+      { mimeType: `image/${input.format ?? "webp"}` }
+    );
+    const artifact = {
+      pageRef: page.pageRef,
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      payload,
+      format: input.format ?? "webp",
+      size: targetSize,
+      coordinateSpace: input.clipSpace ?? "layout-viewport-css",
+      ...input.clip === void 0 ? {} : { clip: input.clip }
+    };
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: artifact
+    });
+  }
+  async setExecutionState(input) {
+    const page = this.requirePage(input.pageRef);
+    const pausedChanged = input.paused !== void 0 && input.paused !== page.paused;
+    const frozenChanged = input.frozen !== void 0 && input.frozen !== page.frozen;
+    const nextPaused = input.paused ?? page.paused;
+    const nextFrozen = input.frozen ?? page.frozen;
+    if (pausedChanged) {
+      this.requireCapability(
+        nextPaused ? "executor.executionControl.pause" : "executor.executionControl.resume"
+      );
+    }
+    if (frozenChanged) {
+      this.requireCapability("executor.executionControl.freeze");
+    }
+    page.paused = nextPaused;
+    page.frozen = nextFrozen;
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    const events = this.drainQueuedEvents(page.pageRef);
+    if (pausedChanged) {
+      const executionEvent = this.maybeCreateEvent({
+        kind: nextPaused ? "paused" : "resumed",
+        sessionRef: page.sessionRef,
+        pageRef: page.pageRef,
+        frameRef: mainFrame.frameRef,
+        documentRef: mainFrame.documentRef,
+        documentEpoch: mainFrame.documentEpoch
+      });
+      if (executionEvent) {
+        events.push(executionEvent);
+      }
+    }
+    if (frozenChanged && nextFrozen) {
+      const frozenEvent = this.maybeCreateEvent({
+        kind: "frozen",
+        sessionRef: page.sessionRef,
+        pageRef: page.pageRef,
+        frameRef: mainFrame.frameRef,
+        documentRef: mainFrame.documentRef,
+        documentEpoch: mainFrame.documentEpoch
+      });
+      if (frozenEvent) {
+        events.push(frozenEvent);
+      }
+    }
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events,
+      data: {
+        paused: page.paused,
+        frozen: page.frozen
+      }
+    });
+  }
+  async listPages(input) {
+    this.requireCapability("inspector.pageEnumeration");
+    const session = this.requireSession(input.sessionRef);
+    return Array.from(
+      session.pageRefs,
+      (pageRef) => clone(this.pageInfoFromState(this.requirePage(pageRef)))
+    );
+  }
+  async listFrames(input) {
+    this.requireCapability("inspector.frameEnumeration");
+    const page = this.requirePage(input.pageRef);
+    return Array.from(page.frameRefs, (frameRef) => clone(this.requireFrame(frameRef).frameInfo));
+  }
+  async getPageInfo(input) {
+    this.requireCapability("inspector.pageEnumeration");
+    return clone(this.pageInfoFromState(this.requirePage(input.pageRef)));
+  }
+  async getFrameInfo(input) {
+    this.requireCapability("inspector.frameEnumeration");
+    return clone(this.requireFrame(input.frameRef).frameInfo);
+  }
+  async getHtmlSnapshot(input) {
+    this.requireCapability("inspector.html");
+    const document = this.resolveDocumentInput(input);
+    return clone(document.htmlSnapshot);
+  }
+  async getDomSnapshot(input) {
+    this.requireCapability("inspector.domSnapshot");
+    const document = this.resolveDocumentInput(input);
+    return clone(document.domSnapshot);
+  }
+  async waitForVisualStability(_input) {
+    this.requireCapability("inspector.visualStability");
+  }
+  async readText(input) {
+    this.requireCapability("inspector.text");
+    const document = this.requireLiveNode(input);
+    return clone(document.nodeText.get(input.nodeRef) ?? null);
+  }
+  async readAttributes(input) {
+    this.requireCapability("inspector.attributes");
+    const document = this.requireLiveNode(input);
+    return clone(document.nodeAttributes.get(input.nodeRef) ?? []);
+  }
+  async hitTest(input) {
+    this.requireCapability("inspector.hitTest");
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    const document = this.requireDocument(mainFrame.documentRef);
+    const resolvedPoint = this.resolvePoint(
+      page.viewportMetrics,
+      input.point,
+      input.coordinateSpace
+    );
+    const key = this.hitTestKey(resolvedPoint, input.ignorePointerEventsNone ?? false);
+    const hit = document.hitTests.get(key);
+    if (hit) {
+      return clone({
+        inputPoint: input.point,
+        inputCoordinateSpace: input.coordinateSpace,
+        ...hit
+      });
+    }
+    return {
+      inputPoint: input.point,
+      inputCoordinateSpace: input.coordinateSpace,
+      resolvedPoint,
+      resolvedCoordinateSpace: "document-css",
+      pageRef: page.pageRef,
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      obscured: false,
+      pointerEventsSkipped: false
+    };
+  }
+  async getViewportMetrics(input) {
+    this.requireCapability("inspector.viewportMetrics");
+    return clone(this.requirePage(input.pageRef).viewportMetrics);
+  }
+  async getNetworkRecords(input) {
+    this.requireCapability("inspector.network");
+    input.signal?.throwIfAborted?.();
+    const session = this.requireSession(input.sessionRef);
+    const records = [];
+    const includeBodies = input.includeBodies ?? false;
+    const pageRefs = input.pageRef === void 0 ? Array.from(session.pageRefs) : [input.pageRef];
+    const requestIds = input.requestIds === void 0 ? void 0 : new Set(input.requestIds);
+    for (const pageRef of pageRefs) {
+      const page = this.requirePage(pageRef);
+      const mainFrame = this.getMainFrame(page.pageRef);
+      const document = this.requireDocument(mainFrame.frameInfo.documentRef);
+      records.push(
+        ...document.networkRecords.filter(
+          (record) => (requestIds === void 0 || requestIds.has(record.requestId)) && matchesNetworkRecordFilters(record, input)
+        ).map((record) => clone(record))
+      );
+    }
+    if (!includeBodies) {
+      return records.map(
+        ({ requestBody: _requestBody, responseBody: _responseBody, ...record }) => ({
+          ...record
+        })
+      );
+    }
+    this.requireCapability("inspector.networkBodies");
+    return records;
+  }
+  async getCookies(input) {
+    this.requireCapability("inspector.cookies");
+    const session = this.requireSession(input.sessionRef);
+    const cookies = input.urls && input.urls.length > 0 ? filterCookieRecords(session.cookies, input.urls) : session.cookies;
+    return cookies.map((cookie) => clone(cookie));
+  }
+  async setCookies(input) {
+    const session = this.requireSession(input.sessionRef);
+    const merged = new Map(
+      session.cookies.map((cookie) => [
+        `${cookie.name}\0${cookie.domain}\0${cookie.path}`,
+        clone(cookie)
+      ])
+    );
+    for (const cookie of input.cookies) {
+      merged.set(`${cookie.name}\0${cookie.domain}\0${cookie.path}`, clone(cookie));
+    }
+    session.cookies = [...merged.values()];
+  }
+  async getStorageSnapshot(input) {
+    const session = this.requireSession(input.sessionRef);
+    this.requireCapability("inspector.localStorage");
+    if (input.includeSessionStorage ?? true) {
+      this.requireCapability("inspector.sessionStorage");
+    }
+    if (input.includeIndexedDb ?? true) {
+      this.requireCapability("inspector.indexedDb");
+    }
+    const snapshot = clone(session.storage);
+    return {
+      sessionRef: snapshot.sessionRef,
+      capturedAt: snapshot.capturedAt,
+      origins: snapshot.origins.map((origin) => ({
+        origin: origin.origin,
+        localStorage: origin.localStorage,
+        ...(input.includeIndexedDb ?? true) && origin.indexedDb ? { indexedDb: origin.indexedDb } : {}
+      })),
+      ...input.includeSessionStorage ?? true ? { sessionStorage: snapshot.sessionStorage ?? [] } : {}
+    };
+  }
+  async evaluatePage(input) {
+    const page = this.requirePage(input.pageRef);
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    const value = await Promise.resolve().then(() => {
+      const evaluated = (0, eval)(input.script);
+      if (typeof evaluated === "function") {
+        return evaluated(...input.args ?? []);
+      }
+      return evaluated;
+    });
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameRef,
+      documentRef: mainFrame.documentRef,
+      documentEpoch: mainFrame.documentEpoch,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: clone(value)
+    });
+  }
+  async executeRequest(input) {
+    this.requireCapability("transport.sessionHttp");
+    input.signal?.throwIfAborted?.();
+    const session = this.requireSession(input.sessionRef);
+    const key = buildTransportKey(input.request);
+    const seededResponse = session.transportResponses.get(key);
+    const response = seededResponse ?? {
+      url: input.request.url,
+      status: 200,
+      statusText: "OK",
+      headers: [createHeaderEntry("content-type", "text/plain; charset=utf-8")],
+      body: bodyPayloadFromUtf8(`${input.request.method.toUpperCase()} ${input.request.url}`, {
+        mimeType: "text/plain"
+      }),
+      redirected: false
+    };
+    const requestId = createNetworkRequestId(`transport-${++this.requestCounter}`);
+    const transportRecord = {
+      kind: "http",
+      requestId,
+      sessionRef: input.sessionRef,
+      method: input.request.method.toUpperCase(),
+      url: input.request.url,
+      requestHeaders: input.request.headers ?? [],
+      responseHeaders: response.headers,
+      status: response.status,
+      statusText: response.statusText,
+      resourceType: "fetch",
+      navigationRequest: false,
+      captureState: "complete",
+      requestBodyState: input.request.body === void 0 ? "skipped" : "complete",
+      responseBodyState: response.body === void 0 ? "skipped" : "complete",
+      ...input.request.body === void 0 ? { requestBodySkipReason: "not-present" } : {},
+      ...response.body === void 0 ? { responseBodySkipReason: "not-present" } : {},
+      ...input.request.body === void 0 ? {} : { requestBody: input.request.body },
+      ...response.body === void 0 ? {} : { responseBody: response.body }
+    };
+    for (const pageRef of session.pageRefs) {
+      const mainFrame = this.getMainFrame(pageRef);
+      this.requireDocument(mainFrame.frameInfo.documentRef).networkRecords.push(transportRecord);
+      break;
+    }
+    return this.createStepResult(input.sessionRef, void 0, {
+      events: [],
+      data: clone(response)
+    });
+  }
+  createPageInternal(sessionRef, options) {
+    const session = this.requireSession(sessionRef);
+    const pageRef = createPageRef(`fake-${++this.pageCounter}`);
+    const frameRef = createFrameRef(`fake-${++this.frameCounter}`);
+    const documentRef = createDocumentRef(`fake-${++this.documentCounter}`);
+    const documentEpoch = createDocumentEpoch(0);
+    const url = options.url ?? "about:blank";
+    const title = options.title ?? titleFromUrl(url);
+    const viewportSize = options.viewportSize ?? createSize(1280, 720);
+    const page = {
+      pageRef,
+      sessionRef,
+      frameRefs: /* @__PURE__ */ new Set([frameRef]),
+      queuedEvents: [],
+      history: [url],
+      historyIndex: 0,
+      lifecycleState: "open",
+      paused: false,
+      frozen: false,
+      viewportMetrics: {
+        layoutViewport: {
+          origin: createPoint(0, 0),
+          size: viewportSize
+        },
+        visualViewport: {
+          origin: createPoint(0, 0),
+          offsetWithinLayoutViewport: createScrollOffset(0, 0),
+          size: viewportSize
+        },
+        scrollOffset: createScrollOffset(0, 0),
+        contentSize: createSize(1280, 2400),
+        devicePixelRatio: createDevicePixelRatio(2),
+        pageScaleFactor: createPageScaleFactor(1),
+        pageZoomFactor: createPageZoomFactor(1)
+      },
+      ...options.openerPageRef === void 0 ? {} : { openerPageRef: options.openerPageRef }
+    };
+    const frameInfo = {
+      frameRef,
+      pageRef,
+      documentRef,
+      documentEpoch,
+      url,
+      isMainFrame: true
+    };
+    this.pages.set(pageRef, page);
+    this.frames.set(frameRef, { frameInfo });
+    session.pageRefs.add(pageRef);
+    this.rebuildDocumentStateForFrame(pageRef, frameRef, {
+      documentRef,
+      documentEpoch,
+      url,
+      title
+    });
+    session.storage = this.seedDefaultSessionStorage(session.storage, pageRef, frameRef, url);
+    return {
+      pageInfo: this.pageInfoFromState(page, url, title),
+      frameInfo
+    };
+  }
+  pageInfoFromState(page, url, title) {
+    const mainFrame = this.getMainFrameInfo(page.pageRef);
+    return {
+      pageRef: page.pageRef,
+      sessionRef: page.sessionRef,
+      url: url ?? mainFrame.url,
+      title: title ?? titleFromUrl(mainFrame.url),
+      lifecycleState: page.lifecycleState,
+      ...page.openerPageRef === void 0 ? {} : { openerPageRef: page.openerPageRef }
+    };
+  }
+  createDefaultStorage(sessionRef) {
+    return {
+      sessionRef,
+      capturedAt: this.timestampMs,
+      origins: [
+        {
+          origin: "https://example.com",
+          localStorage: [
+            { key: "theme", value: "dark" },
+            { key: "draft", value: "hello" }
+          ],
+          indexedDb: [
+            {
+              name: "app-db",
+              version: 1,
+              objectStores: [
+                {
+                  name: "messages",
+                  keyPath: "id",
+                  autoIncrement: false,
+                  indexes: [],
+                  records: [
+                    {
+                      key: "1",
+                      value: { id: "1", text: "hello" }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      sessionStorage: []
+    };
+  }
+  seedDefaultSessionStorage(storage, pageRef, frameRef, url) {
+    const origin = originFromUrl(url);
+    if (origin === void 0) {
+      return storage;
+    }
+    if (storage.sessionStorage?.some(
+      (snapshot) => snapshot.pageRef === pageRef && snapshot.frameRef === frameRef && snapshot.origin === origin
+    )) {
+      return storage;
+    }
+    return {
+      ...storage,
+      sessionStorage: [
+        ...storage.sessionStorage ?? [],
+        {
+          pageRef,
+          frameRef,
+          origin,
+          entries: [{ key: "csrf", value: "token-123" }]
+        }
+      ]
+    };
+  }
+  async performNavigation(pageRef, url, options) {
+    this.requireCapability("executor.navigation");
+    const page = this.requirePage(pageRef);
+    const mainFrame = this.getMainFrame(page.pageRef);
+    const currentFrameInfo = mainFrame.frameInfo;
+    const currentDocument = this.requireDocument(currentFrameInfo.documentRef);
+    const sameDocument = !options.forceNewDocument && stripFragment(currentFrameInfo.url) === stripFragment(url);
+    const title = titleFromUrl(url);
+    const requestBody = options.referrer === void 0 ? void 0 : bodyPayloadFromUtf8(options.referrer, { mimeType: "text/plain" });
+    const requestHeaders = options.referrer === void 0 ? [] : [createHeaderEntry("referer", options.referrer)];
+    let nextDocumentRef = currentFrameInfo.documentRef;
+    let nextDocumentEpoch2 = currentFrameInfo.documentEpoch;
+    if (sameDocument) {
+      currentDocument.url = url;
+      currentDocument.htmlSnapshot = {
+        ...currentDocument.htmlSnapshot,
+        url,
+        capturedAt: this.nextTimestamp()
+      };
+      currentDocument.domSnapshot = {
+        ...currentDocument.domSnapshot,
+        url,
+        capturedAt: this.nextTimestamp()
+      };
+      mainFrame.frameInfo = {
+        ...currentFrameInfo,
+        url
+      };
+    } else {
+      nextDocumentRef = createDocumentRef(`fake-${++this.documentCounter}`);
+      nextDocumentEpoch2 = createDocumentEpoch(0);
+      mainFrame.frameInfo = {
+        ...currentFrameInfo,
+        url,
+        documentRef: nextDocumentRef,
+        documentEpoch: nextDocumentEpoch2
+      };
+      this.rebuildDocumentStateForFrame(page.pageRef, currentFrameInfo.frameRef, {
+        documentRef: nextDocumentRef,
+        documentEpoch: nextDocumentEpoch2,
+        url,
+        title
+      });
+      this.retireDocument(currentFrameInfo.documentRef);
+      const requestId = createNetworkRequestId(`fake-${++this.requestCounter}`);
+      const responseBody = bodyPayloadFromUtf8(`<html><title>${title}</title></html>`, {
+        mimeType: "text/html"
+      });
+      this.requireDocument(nextDocumentRef).networkRecords.push({
+        kind: "http",
+        requestId,
+        sessionRef: page.sessionRef,
+        pageRef: page.pageRef,
+        frameRef: currentFrameInfo.frameRef,
+        documentRef: nextDocumentRef,
+        method: "GET",
+        url,
+        requestHeaders,
+        responseHeaders: [
+          createHeaderEntry("content-type", "text/html; charset=utf-8"),
+          createHeaderEntry("set-cookie", "session=abc"),
+          createHeaderEntry("set-cookie", "theme=dark")
+        ],
+        status: 200,
+        statusText: "OK",
+        resourceType: "document",
+        navigationRequest: true,
+        captureState: "complete",
+        requestBodyState: requestBody === void 0 ? "skipped" : "complete",
+        responseBodyState: "complete",
+        ...requestBody === void 0 ? { requestBodySkipReason: "not-present" } : {},
+        timing: {
+          requestStartMs: this.timestampMs,
+          responseStartMs: this.timestampMs + 5,
+          responseEndMs: this.timestampMs + 10
+        },
+        transfer: {
+          encodedBodyBytes: responseBody.capturedByteLength,
+          decodedBodyBytes: responseBody.capturedByteLength,
+          transferSizeBytes: responseBody.capturedByteLength + 256
+        },
+        ...requestBody === void 0 ? {} : { requestBody },
+        responseBody
+      });
+    }
+    if (options.recordHistory) {
+      page.history = [...page.history.slice(0, page.historyIndex + 1), url];
+      page.historyIndex = page.history.length - 1;
+    }
+    const pageInfo = this.pageInfoFromState(page, url, title);
+    return this.createStepResult(page.sessionRef, page.pageRef, {
+      frameRef: mainFrame.frameInfo.frameRef,
+      documentRef: nextDocumentRef,
+      documentEpoch: nextDocumentEpoch2,
+      events: this.drainQueuedEvents(page.pageRef),
+      data: {
+        pageInfo,
+        mainFrame: clone(mainFrame.frameInfo)
+      }
+    });
+  }
+  createDocumentSnapshot(pageRef, frameRef, documentRef, documentEpoch, url, title) {
+    const bodyRect = createRect(0, 0, 1280, 2400);
+    const buttonRect = createRect(16, 16, 160, 48);
+    const obscuredRect = createRect(240, 16, 160, 48);
+    const titleRect = createRect(16, 96, 220, 32);
+    const buttonRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const obscuredRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const documentNodeRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const htmlNodeRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const bodyNodeRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const titleRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const hiddenPanelRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const shadowHostRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const shadowActionRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const nestedShadowHostRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const nestedShadowActionRef = createNodeRef(`fake-${++this.nodeCounter}`);
+    const nodes = [
+      {
+        snapshotNodeId: 1,
+        nodeRef: documentNodeRef,
+        childSnapshotNodeIds: [2],
+        nodeType: 9,
+        nodeName: "#document",
+        nodeValue: "",
+        attributes: []
+      },
+      {
+        snapshotNodeId: 2,
+        nodeRef: htmlNodeRef,
+        parentSnapshotNodeId: 1,
+        childSnapshotNodeIds: [3],
+        nodeType: 1,
+        nodeName: "HTML",
+        nodeValue: "",
+        attributes: []
+      },
+      {
+        snapshotNodeId: 3,
+        nodeRef: bodyNodeRef,
+        parentSnapshotNodeId: 2,
+        childSnapshotNodeIds: [4, 5, 6, 7, 8, 9, 10, 11],
+        nodeType: 1,
+        nodeName: "BODY",
+        nodeValue: "",
+        attributes: [],
+        layout: {
+          rect: bodyRect,
+          quad: rectToQuad(bodyRect),
+          paintOrder: 1
+        }
+      },
+      {
+        snapshotNodeId: 4,
+        nodeRef: buttonRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "BUTTON",
+        nodeValue: "",
+        textContent: "Continue",
+        attributes: [
+          { name: "id", value: "continue" },
+          { name: "type", value: "button" }
+        ],
+        layout: {
+          rect: buttonRect,
+          quad: rectToQuad(buttonRect),
+          paintOrder: 2
+        }
+      },
+      {
+        snapshotNodeId: 5,
+        nodeRef: obscuredRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "DIV",
+        nodeValue: "",
+        textContent: "Overlay",
+        attributes: [{ name: "id", value: "overlay" }],
+        layout: {
+          rect: obscuredRect,
+          quad: rectToQuad(obscuredRect),
+          paintOrder: 3
+        }
+      },
+      {
+        snapshotNodeId: 6,
+        nodeRef: titleRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "H1",
+        nodeValue: "",
+        textContent: "Snapshot Heading",
+        attributes: [{ name: "id", value: "snapshot-title" }],
+        layout: {
+          rect: titleRect,
+          quad: rectToQuad(titleRect),
+          paintOrder: 4
+        }
+      },
+      {
+        snapshotNodeId: 7,
+        nodeRef: hiddenPanelRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "DIV",
+        nodeValue: "",
+        textContent: "Hidden panel",
+        computedStyle: {
+          display: "none"
+        },
+        attributes: [{ name: "id", value: "hidden-panel" }]
+      },
+      {
+        snapshotNodeId: 8,
+        nodeRef: shadowHostRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "DIV",
+        nodeValue: "",
+        textContent: "",
+        attributes: [{ name: "id", value: "shadow-host" }]
+      },
+      {
+        snapshotNodeId: 9,
+        nodeRef: shadowActionRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        shadowHostNodeRef: shadowHostRef,
+        nodeType: 1,
+        nodeName: "BUTTON",
+        nodeValue: "",
+        textContent: "Shadow Action",
+        attributes: [{ name: "id", value: "shadow-action" }]
+      },
+      {
+        snapshotNodeId: 10,
+        nodeRef: nestedShadowHostRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        nodeType: 1,
+        nodeName: "DIV",
+        nodeValue: "",
+        textContent: "",
+        attributes: [{ name: "id", value: "nested-shadow-host" }]
+      },
+      {
+        snapshotNodeId: 11,
+        nodeRef: nestedShadowActionRef,
+        parentSnapshotNodeId: 3,
+        childSnapshotNodeIds: [],
+        shadowHostNodeRef: nestedShadowHostRef,
+        nodeType: 1,
+        nodeName: "BUTTON",
+        nodeValue: "",
+        textContent: "Nested Shadow",
+        attributes: [{ name: "id", value: "nested-shadow-action" }]
+      }
+    ];
+    const domSnapshot = {
+      pageRef,
+      frameRef,
+      documentRef,
+      documentEpoch,
+      url,
+      capturedAt: this.timestampMs,
+      rootSnapshotNodeId: 1,
+      shadowDomMode: "flattened",
+      geometryCoordinateSpace: "document-css",
+      nodes
+    };
+    const nodeText = /* @__PURE__ */ new Map([
+      [buttonRef, "Continue"],
+      [obscuredRef, "Overlay"],
+      [titleRef, "Snapshot Heading"],
+      [hiddenPanelRef, "Hidden panel"],
+      [shadowHostRef, ""],
+      [shadowActionRef, "Shadow Action"],
+      [nestedShadowHostRef, ""],
+      [nestedShadowActionRef, "Nested Shadow"],
+      [documentNodeRef, null],
+      [htmlNodeRef, null],
+      [bodyNodeRef, null]
+    ]);
+    const nodeAttributes = /* @__PURE__ */ new Map([
+      [buttonRef, nodes[3].attributes],
+      [obscuredRef, nodes[4].attributes],
+      [titleRef, nodes[5].attributes],
+      [hiddenPanelRef, nodes[6].attributes],
+      [shadowHostRef, nodes[7].attributes],
+      [shadowActionRef, nodes[8].attributes],
+      [nestedShadowHostRef, nodes[9].attributes],
+      [nestedShadowActionRef, nodes[10].attributes],
+      [documentNodeRef, []],
+      [htmlNodeRef, []],
+      [bodyNodeRef, []]
+    ]);
+    const nodeRects = /* @__PURE__ */ new Map([
+      [buttonRef, buttonRect],
+      [obscuredRef, obscuredRect],
+      [titleRef, titleRect],
+      [bodyNodeRef, bodyRect]
+    ]);
+    const hitTests = /* @__PURE__ */ new Map([
+      [
+        this.hitTestKey(createPoint(20, 20), false),
+        {
+          resolvedPoint: createPoint(20, 20),
+          resolvedCoordinateSpace: "document-css",
+          pageRef,
+          frameRef,
+          documentRef,
+          documentEpoch,
+          nodeRef: buttonRef,
+          targetQuad: rectToQuad(buttonRect),
+          obscured: false,
+          pointerEventsSkipped: false
+        }
+      ],
+      [
+        this.hitTestKey(createPoint(260, 20), false),
+        {
+          resolvedPoint: createPoint(260, 20),
+          resolvedCoordinateSpace: "document-css",
+          pageRef,
+          frameRef,
+          documentRef,
+          documentEpoch,
+          nodeRef: obscuredRef,
+          targetQuad: rectToQuad(obscuredRect),
+          obscured: true,
+          pointerEventsSkipped: false
+        }
+      ],
+      [
+        this.hitTestKey(createPoint(20, 20), true),
+        {
+          resolvedPoint: createPoint(20, 20),
+          resolvedCoordinateSpace: "document-css",
+          pageRef,
+          frameRef,
+          documentRef,
+          documentEpoch,
+          nodeRef: buttonRef,
+          targetQuad: rectToQuad(buttonRect),
+          obscured: false,
+          pointerEventsSkipped: true
+        }
+      ]
+    ]);
+    return {
+      htmlSnapshot: {
+        pageRef,
+        frameRef,
+        documentRef,
+        documentEpoch,
+        url,
+        capturedAt: this.timestampMs,
+        html: `<html><head><title>${title}</title></head><body><button id="continue" type="button">Continue</button><div id="overlay">Overlay</div><h1 id="snapshot-title">Snapshot Heading</h1><div id="hidden-panel" style="display:none">Hidden panel</div><div id="shadow-host"></div><button id="shadow-action">Shadow Action</button><div id="nested-shadow-host"></div><button id="nested-shadow-action">Nested Shadow</button></body></html>`
+      },
+      domSnapshot,
+      nodeText,
+      nodeAttributes,
+      nodeRects,
+      hitTests,
+      networkRecords: []
+    };
+  }
+  rebuildDocumentStateForFrame(pageRef, frameRef, input) {
+    const nextState = this.createDocumentSnapshot(
+      pageRef,
+      frameRef,
+      input.documentRef,
+      input.documentEpoch,
+      input.url,
+      input.title
+    );
+    this.retiredDocuments.delete(input.documentRef);
+    this.documents.set(input.documentRef, {
+      pageRef,
+      frameRef,
+      documentRef: input.documentRef,
+      documentEpoch: input.documentEpoch,
+      url: input.url,
+      ...nextState
+    });
+  }
+  rebuildDocumentState(documentRef, input) {
+    const existing = this.requireDocument(documentRef);
+    this.rebuildDocumentStateForFrame(existing.pageRef, existing.frameRef, input);
+    const frame = this.requireFrame(existing.frameRef);
+    frame.frameInfo = {
+      ...frame.frameInfo,
+      documentRef: input.documentRef,
+      documentEpoch: input.documentEpoch,
+      url: input.url
+    };
+  }
+  resolveDocumentInput(input) {
+    if (input.frameRef && input.documentRef) {
+      throw createBrowserCoreError(
+        "invalid-argument",
+        "provide either frameRef or documentRef, not both"
+      );
+    }
+    if (input.documentRef) {
+      return this.requireDocument(input.documentRef);
+    }
+    if (input.frameRef) {
+      return this.requireDocument(this.requireFrame(input.frameRef).frameInfo.documentRef);
+    }
+    throw createBrowserCoreError("invalid-argument", "either frameRef or documentRef is required");
+  }
+  requireLiveNode(input) {
+    if (this.retiredDocuments.has(input.documentRef)) {
+      throw staleNodeRefError(input);
+    }
+    const document = this.requireDocument(input.documentRef);
+    if (document.documentEpoch !== input.documentEpoch) {
+      throw staleNodeRefError(input);
+    }
+    const node = findDomSnapshotNodeByRef(document.domSnapshot, input.nodeRef);
+    if (!node) {
+      throw staleNodeRefError(input);
+    }
+    return document;
+  }
+  resolvePoint(metrics, point, coordinateSpace) {
+    switch (coordinateSpace) {
+      case "document-css":
+        return point;
+      case "layout-viewport-css":
+      case "visual-viewport-css":
+        return createPoint(point.x + metrics.scrollOffset.x, point.y + metrics.scrollOffset.y);
+      case "computer-display-css":
+        throw createBrowserCoreError(
+          "unsupported-capability",
+          `coordinate space ${coordinateSpace} is not supported by the fake engine`,
+          {
+            details: {
+              coordinateSpace
+            }
+          }
+        );
+      case "window":
+      case "screen":
+      case "device-pixel":
+        return createPoint(
+          point.x / metrics.devicePixelRatio + metrics.scrollOffset.x,
+          point.y / metrics.devicePixelRatio + metrics.scrollOffset.y
+        );
+    }
+    throw createBrowserCoreError(
+      "invalid-argument",
+      `coordinate space ${coordinateSpace} is not supported by the fake engine`
+    );
+  }
+  hitTestKey(point, ignorePointerEventsNone) {
+    return `${Math.round(point.x)}:${Math.round(point.y)}:${ignorePointerEventsNone ? "ignore" : "respect"}`;
+  }
+  requireCapability(path) {
+    if (!hasCapability(this.capabilities, path)) {
+      throw unsupportedCapabilityError(path);
+    }
+  }
+  assertEventCapability(kind) {
+    const capability = this.eventCapabilityForKind(kind);
+    if (!hasCapability(this.capabilities, capability)) {
+      throw unsupportedCapabilityError(capability);
+    }
+  }
+  eventCapabilityForKind(kind) {
+    switch (kind) {
+      case "page-created":
+      case "popup-opened":
+      case "page-closed":
+        return "events.pageLifecycle";
+      case "dialog-opened":
+        return "events.dialog";
+      case "download-started":
+      case "download-finished":
+        return "events.download";
+      case "chooser-opened":
+        return "events.chooser";
+      case "worker-created":
+      case "worker-destroyed":
+        return "events.worker";
+      case "console":
+        return "events.console";
+      case "page-error":
+        return "events.pageError";
+      case "websocket-opened":
+      case "websocket-frame":
+      case "websocket-closed":
+        return "events.websocket";
+      case "event-stream-message":
+        return "events.eventStream";
+      case "paused":
+      case "resumed":
+      case "frozen":
+        return "events.executionState";
+    }
+  }
+  createEvent(value) {
+    this.assertEventCapability(value.kind);
+    return {
+      ...value,
+      eventId: `event:${++this.eventCounter}`,
+      timestamp: this.nextTimestamp()
+    };
+  }
+  maybeCreateEvent(value) {
+    if (!hasCapability(this.capabilities, this.eventCapabilityForKind(value.kind))) {
+      return void 0;
+    }
+    return this.createEvent(value);
+  }
+  createStepResult(sessionRef, pageRef, input) {
+    const startedAt = this.nextTimestamp();
+    const completedAt = this.nextTimestamp();
+    return {
+      stepId: `step:${++this.stepCounter}`,
+      sessionRef,
+      startedAt,
+      completedAt,
+      durationMs: completedAt - startedAt,
+      events: input.events.map((event) => clone(event)),
+      data: clone(input.data),
+      ...pageRef === void 0 ? {} : { pageRef },
+      ...input.frameRef === void 0 ? {} : { frameRef: input.frameRef },
+      ...input.documentRef === void 0 ? {} : { documentRef: input.documentRef },
+      ...input.documentEpoch === void 0 ? {} : { documentEpoch: input.documentEpoch }
+    };
+  }
+  drainQueuedEvents(pageRef) {
+    const page = this.requirePage(pageRef);
+    const events = page.queuedEvents.splice(0, page.queuedEvents.length);
+    return events.map((event) => clone(event));
+  }
+  requireSession(sessionRef) {
+    const session = this.sessions.get(sessionRef);
+    if (!session) {
+      throw closedSessionError(sessionRef);
+    }
+    return session;
+  }
+  requirePage(pageRef) {
+    const page = this.pages.get(pageRef);
+    if (!page || page.lifecycleState === "closed") {
+      throw closedPageError(pageRef);
+    }
+    return page;
+  }
+  requireFrame(frameRef) {
+    const frame = this.frames.get(frameRef);
+    if (!frame) {
+      throw createBrowserCoreError("not-found", `frame ${frameRef} was not found`, {
+        details: { frameRef }
+      });
+    }
+    return frame;
+  }
+  requireDocument(documentRef) {
+    const document = this.documents.get(documentRef);
+    if (!document) {
+      throw createBrowserCoreError("not-found", `document ${documentRef} was not found`, {
+        details: { documentRef }
+      });
+    }
+    return document;
+  }
+  getMainFrame(pageRef) {
+    const page = this.requirePage(pageRef);
+    const mainFrameRef = Array.from(page.frameRefs).find(
+      (frameRef) => this.requireFrame(frameRef).frameInfo.isMainFrame
+    );
+    if (!mainFrameRef) {
+      throw createBrowserCoreError("operation-failed", `page ${pageRef} has no main frame`);
+    }
+    return this.requireFrame(mainFrameRef);
+  }
+  getMainFrameInfo(pageRef) {
+    return clone(this.getMainFrame(pageRef).frameInfo);
+  }
+  destroyPage(pageRef) {
+    const page = this.requirePage(pageRef);
+    page.lifecycleState = "closed";
+    this.pages.delete(pageRef);
+    const session = this.requireSession(page.sessionRef);
+    session.pageRefs.delete(pageRef);
+    for (const frameRef of page.frameRefs) {
+      const frame = this.frames.get(frameRef);
+      if (!frame) {
+        continue;
+      }
+      this.documents.delete(frame.frameInfo.documentRef);
+      this.frames.delete(frameRef);
+    }
+  }
+  retireDocument(documentRef) {
+    this.documents.delete(documentRef);
+    this.retiredDocuments.add(documentRef);
+  }
+  nextTimestamp() {
+    return this.timestampMs += 5;
+  }
+};
+function createFakeBrowserCoreEngine(options = {}) {
+  const capabilities = options.capabilities ?? allBrowserCapabilities();
+  return new FakeBrowserCoreEngine({ ...options, capabilities });
+}
+
+// src/cdp-dom-snapshot.ts
+var DOM_SNAPSHOT_COMPUTED_STYLE_NAMES = [
+  "display",
+  "visibility",
+  "opacity",
+  "position",
+  "cursor",
+  "overflow-x",
+  "overflow-y"
+];
+function parseCdpStringTable(strings, index) {
+  if (index === void 0 || index < 0) {
+    return "";
+  }
+  return strings[index] ?? "";
+}
+function rareCdpStringValue(strings, data, index) {
+  if (!data) {
+    return void 0;
+  }
+  const matchIndex = data.index.findIndex((candidate) => candidate === index);
+  if (matchIndex === -1) {
+    return void 0;
+  }
+  return parseCdpStringTable(strings, data.value[matchIndex]);
+}
+function rareCdpIntegerValue(data, index) {
+  if (!data) {
+    return void 0;
+  }
+  const matchIndex = data.index.findIndex((candidate) => candidate === index);
+  if (matchIndex === -1) {
+    return void 0;
+  }
+  return data.value[matchIndex];
+}
+function normalizeCdpShadowRootType(value) {
+  switch (value) {
+    case "open":
+    case "closed":
+      return value;
+    case "user-agent":
+    case "user_agent":
+      return "user-agent";
+    default:
+      return void 0;
+  }
+}
+function buildCdpShadowBoundaryIndex(root) {
+  const byBackendNodeId = /* @__PURE__ */ new Map();
+  const visit = (node, boundary) => {
+    if (node.backendNodeId !== void 0) {
+      byBackendNodeId.set(node.backendNodeId, boundary);
+    }
+    for (const child of node.children ?? []) {
+      visit(child, boundary);
+    }
+    for (const shadowRoot of node.shadowRoots ?? []) {
+      const normalizedShadowRootType = normalizeCdpShadowRootType(shadowRoot.shadowRootType);
+      const shadowBoundary = {
+        ...node.backendNodeId === void 0 ? {} : { shadowHostBackendNodeId: node.backendNodeId },
+        ...normalizedShadowRootType === void 0 ? {} : { shadowRootType: normalizedShadowRootType }
+      };
+      if (shadowRoot.backendNodeId !== void 0) {
+        byBackendNodeId.set(shadowRoot.backendNodeId, shadowBoundary);
+      }
+      for (const child of shadowRoot.children ?? []) {
+        visit(child, shadowBoundary);
+      }
+    }
+    if (node.contentDocument) {
+      visit(node.contentDocument, {});
+    }
+  };
+  visit(root, {});
+  return byBackendNodeId;
+}
+function buildDomSnapshotFromCdpCapture(document, captured, nodeRefResolver, contentDocRefResolver) {
+  const parentIndexes = captured.rawDocument.nodes.parentIndex ?? [];
+  const childIndexes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < parentIndexes.length; index += 1) {
+    const parentIndex = parentIndexes[index];
+    if (parentIndex === void 0 || parentIndex < 0) {
+      continue;
+    }
+    const children = childIndexes.get(parentIndex) ?? [];
+    children.push(index);
+    childIndexes.set(parentIndex, children);
+  }
+  const layoutByNodeIndex = decodeLayoutByNodeIndex(captured.rawDocument, captured.strings);
+  const aggregatedTextByNodeIndex = buildAggregatedTextIndex(
+    captured.rawDocument,
+    captured.shadowBoundariesByBackendNodeId,
+    captured.strings
+  );
+  const rootNodeIndex = findRootNodeIndex(parentIndexes);
+  const nodes = [];
+  const nodeCount = captured.rawDocument.nodes.nodeType?.length ?? 0;
+  for (let index = 0; index < nodeCount; index += 1) {
+    const backendNodeId = captured.rawDocument.nodes.backendNodeId?.[index];
+    const nodeRef = backendNodeId === void 0 ? void 0 : nodeRefResolver(backendNodeId);
+    const rawAttributes = captured.rawDocument.nodes.attributes?.[index] ?? [];
+    const attributes = [];
+    for (let pairIndex = 0; pairIndex < rawAttributes.length; pairIndex += 2) {
+      const nameIndex = rawAttributes[pairIndex];
+      const valueIndex = rawAttributes[pairIndex + 1];
+      if (nameIndex === void 0 || valueIndex === void 0) {
+        continue;
+      }
+      attributes.push({
+        name: parseCdpStringTable(captured.strings, nameIndex),
+        value: parseCdpStringTable(captured.strings, valueIndex)
+      });
+    }
+    const directShadowRootType = rareCdpStringValue(
+      captured.strings,
+      captured.rawDocument.nodes.shadowRootType,
+      index
+    );
+    const normalizedShadowRootType = normalizeCdpShadowRootType(directShadowRootType);
+    const shadowBoundary = backendNodeId === void 0 ? void 0 : captured.shadowBoundariesByBackendNodeId.get(backendNodeId);
+    const shadowHostNodeRef = shadowBoundary?.shadowHostBackendNodeId === void 0 ? void 0 : nodeRefResolver(shadowBoundary.shadowHostBackendNodeId);
+    const contentDocumentIndex = rareCdpIntegerValue(
+      captured.rawDocument.nodes.contentDocumentIndex,
+      index
+    );
+    const contentDocumentRef = contentDocumentIndex === void 0 ? void 0 : contentDocRefResolver(contentDocumentIndex);
+    const layout = layoutByNodeIndex.get(index);
+    const textContent = aggregatedTextByNodeIndex.get(index);
+    const computedStyle = layout?.computedStyle ?? decodeInlineComputedStyle(attributes);
+    nodes.push({
+      snapshotNodeId: index + 1,
+      ...nodeRef === void 0 ? {} : { nodeRef },
+      ...parentIndexes[index] === void 0 || parentIndexes[index] < 0 ? {} : { parentSnapshotNodeId: parentIndexes[index] + 1 },
+      childSnapshotNodeIds: (childIndexes.get(index) ?? []).map((childIndex) => childIndex + 1),
+      ...normalizedShadowRootType === void 0 ? {} : { shadowRootType: normalizedShadowRootType },
+      ...shadowHostNodeRef === void 0 ? {} : { shadowHostNodeRef },
+      ...contentDocumentRef === void 0 ? {} : { contentDocumentRef },
+      nodeType: captured.rawDocument.nodes.nodeType?.[index] ?? 0,
+      nodeName: parseCdpStringTable(captured.strings, captured.rawDocument.nodes.nodeName?.[index]),
+      nodeValue: parseCdpStringTable(
+        captured.strings,
+        captured.rawDocument.nodes.nodeValue?.[index]
+      ),
+      ...textContent === void 0 || textContent.length === 0 ? {} : { textContent },
+      ...computedStyle === void 0 ? {} : { computedStyle },
+      attributes,
+      ...layout?.rect === void 0 ? {} : {
+        layout: {
+          rect: layout.rect,
+          quad: rectToQuad(layout.rect),
+          ...layout.paintOrder === void 0 ? {} : { paintOrder: layout.paintOrder }
+        }
+      }
+    });
+  }
+  return {
+    pageRef: document.pageRef,
+    frameRef: document.frameRef,
+    documentRef: document.documentRef,
+    ...document.parentDocumentRef === void 0 ? {} : { parentDocumentRef: document.parentDocumentRef },
+    documentEpoch: document.documentEpoch,
+    url: document.url,
+    capturedAt: captured.capturedAt,
+    rootSnapshotNodeId: rootNodeIndex + 1,
+    shadowDomMode: "preserved",
+    geometryCoordinateSpace: "document-css",
+    nodes
+  };
+}
+function findRootNodeIndex(parentIndexes) {
+  const explicitRootIndex = parentIndexes.findIndex(
+    (parentIndex) => parentIndex === void 0 || parentIndex < 0
+  );
+  return explicitRootIndex >= 0 ? explicitRootIndex : 0;
+}
+function decodeLayoutByNodeIndex(document, strings) {
+  const byNodeIndex = /* @__PURE__ */ new Map();
+  for (let layoutIndex = 0; layoutIndex < document.layout.nodeIndex.length; layoutIndex += 1) {
+    const nodeIndex = document.layout.nodeIndex[layoutIndex];
+    if (nodeIndex === void 0) {
+      continue;
+    }
+    const bounds = document.layout.bounds[layoutIndex];
+    const styleIndexes = document.layout.styles?.[layoutIndex];
+    byNodeIndex.set(nodeIndex, {
+      ...bounds === void 0 ? {} : {
+        rect: createRect(bounds[0] ?? 0, bounds[1] ?? 0, bounds[2] ?? 0, bounds[3] ?? 0)
+      },
+      ...document.layout.paintOrders?.[layoutIndex] === void 0 ? {} : { paintOrder: document.layout.paintOrders[layoutIndex] },
+      ...styleIndexes === void 0 ? {} : { computedStyle: decodeComputedStyle(styleIndexes, strings) }
+    });
+  }
+  return byNodeIndex;
+}
+function decodeComputedStyle(styleIndexes, strings) {
+  const styleEntries = DOM_SNAPSHOT_COMPUTED_STYLE_NAMES.reduce(
+    (out, propertyName, propertyIndex) => {
+      const value = parseCdpStringTable(strings, styleIndexes[propertyIndex]);
+      if (value.length > 0) {
+        out[propertyName] = value;
+      }
+      return out;
+    },
+    {}
+  );
+  return {
+    ...styleEntries.display === void 0 ? {} : { display: styleEntries.display },
+    ...styleEntries.visibility === void 0 ? {} : { visibility: styleEntries.visibility },
+    ...styleEntries.opacity === void 0 ? {} : { opacity: styleEntries.opacity },
+    ...styleEntries.position === void 0 ? {} : { position: styleEntries.position },
+    ...styleEntries.cursor === void 0 ? {} : { cursor: styleEntries.cursor },
+    ...styleEntries["overflow-x"] === void 0 ? {} : { overflowX: styleEntries["overflow-x"] },
+    ...styleEntries["overflow-y"] === void 0 ? {} : { overflowY: styleEntries["overflow-y"] }
+  };
+}
+function decodeInlineComputedStyle(attributes) {
+  const styleAttribute = attributes.find((attribute) => attribute.name === "style")?.value;
+  if (styleAttribute === void 0 || styleAttribute.trim().length === 0) {
+    return void 0;
+  }
+  const styleEntries = /* @__PURE__ */ new Map();
+  for (const declaration of styleAttribute.split(";")) {
+    const separatorIndex = declaration.indexOf(":");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const propertyName = declaration.slice(0, separatorIndex).trim().toLowerCase();
+    const propertyValue = declaration.slice(separatorIndex + 1).trim();
+    if (propertyName.length === 0 || propertyValue.length === 0) {
+      continue;
+    }
+    styleEntries.set(propertyName, propertyValue);
+  }
+  const display = styleEntries.get("display");
+  const visibility = styleEntries.get("visibility");
+  const opacity = styleEntries.get("opacity");
+  const position = styleEntries.get("position");
+  const cursor = styleEntries.get("cursor");
+  const overflow = styleEntries.get("overflow");
+  const overflowX = styleEntries.get("overflow-x") ?? overflow;
+  const overflowY = styleEntries.get("overflow-y") ?? overflow;
+  const computedStyle = {
+    ...display === void 0 ? {} : { display },
+    ...visibility === void 0 ? {} : { visibility },
+    ...opacity === void 0 ? {} : { opacity },
+    ...position === void 0 ? {} : { position },
+    ...cursor === void 0 ? {} : { cursor },
+    ...overflowX === void 0 ? {} : { overflowX },
+    ...overflowY === void 0 ? {} : { overflowY }
+  };
+  return Object.keys(computedStyle).length === 0 ? void 0 : computedStyle;
+}
+function buildAggregatedTextIndex(document, shadowBoundariesByBackendNodeId, strings) {
+  const parentIndexes = document.nodes.parentIndex ?? [];
+  const backendNodeIds = document.nodes.backendNodeId ?? [];
+  const childIndexes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < parentIndexes.length; index += 1) {
+    const parentIndex = parentIndexes[index];
+    if (parentIndex === void 0 || parentIndex < 0) {
+      continue;
+    }
+    const children = childIndexes.get(parentIndex) ?? [];
+    children.push(index);
+    childIndexes.set(parentIndex, children);
+  }
+  const layoutTextByNodeIndex = /* @__PURE__ */ new Map();
+  for (let layoutIndex = 0; layoutIndex < document.layout.nodeIndex.length; layoutIndex += 1) {
+    const nodeIndex = document.layout.nodeIndex[layoutIndex];
+    if (nodeIndex === void 0) {
+      continue;
+    }
+    const text = parseCdpStringTable(strings, document.layout.text[layoutIndex]);
+    if (text.length > 0) {
+      layoutTextByNodeIndex.set(nodeIndex, text);
+    }
+  }
+  const shadowHostBackendNodeIdByNodeIndex = /* @__PURE__ */ new Map();
+  const resolveShadowHostBackendNodeId = (index) => {
+    const existing = shadowHostBackendNodeIdByNodeIndex.get(index);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const backendNodeId = backendNodeIds[index];
+    const directShadowHostBackendNodeId = backendNodeId === void 0 ? void 0 : shadowBoundariesByBackendNodeId.get(backendNodeId)?.shadowHostBackendNodeId;
+    if (directShadowHostBackendNodeId !== void 0) {
+      shadowHostBackendNodeIdByNodeIndex.set(index, directShadowHostBackendNodeId);
+      return directShadowHostBackendNodeId;
+    }
+    const parentIndex = parentIndexes[index];
+    if (parentIndex === void 0 || parentIndex < 0) {
+      shadowHostBackendNodeIdByNodeIndex.set(index, null);
+      return null;
+    }
+    const inheritedShadowHostBackendNodeId = resolveShadowHostBackendNodeId(parentIndex);
+    shadowHostBackendNodeIdByNodeIndex.set(index, inheritedShadowHostBackendNodeId);
+    return inheritedShadowHostBackendNodeId;
+  };
+  const memo = /* @__PURE__ */ new Map();
+  const visit = (index) => {
+    const existing = memo.get(index);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const nodeType = document.nodes.nodeType?.[index] ?? 0;
+    const ownText = readOwnNodeText(document, strings, layoutTextByNodeIndex, index);
+    if (nodeType === 3 || nodeType === 4) {
+      memo.set(index, ownText);
+      return ownText;
+    }
+    if (nodeType === 8 || nodeType === 10) {
+      memo.set(index, "");
+      return "";
+    }
+    let text = ownText;
+    const currentShadowHostBackendNodeId = resolveShadowHostBackendNodeId(index);
+    for (const childIndex of childIndexes.get(index) ?? []) {
+      if (resolveShadowHostBackendNodeId(childIndex) !== currentShadowHostBackendNodeId) {
+        continue;
+      }
+      text += visit(childIndex);
+    }
+    memo.set(index, text);
+    return text;
+  };
+  const aggregated = /* @__PURE__ */ new Map();
+  const nodeCount = document.nodes.nodeType?.length ?? 0;
+  for (let index = 0; index < nodeCount; index += 1) {
+    const text = visit(index);
+    if (text.length > 0) {
+      aggregated.set(index, text);
+    }
+  }
+  return aggregated;
+}
+function readOwnNodeText(document, strings, layoutTextByNodeIndex, index) {
+  return rareCdpStringValue(strings, document.nodes.textValue, index) || rareCdpStringValue(strings, document.nodes.inputValue, index) || (document.nodes.nodeType?.[index] === 3 || document.nodes.nodeType?.[index] === 4 ? parseCdpStringTable(strings, document.nodes.nodeValue?.[index]) || layoutTextByNodeIndex.get(index) || "" : "");
+}
+
+// src/cdp-visual-stability.ts
+var DEFAULT_VISUAL_STABILITY_TIMEOUT_MS = 3e4;
+var DEFAULT_VISUAL_STABILITY_SETTLE_MS = 750;
+var FRAME_EVALUATE_GRACE_MS = 200;
+var TRANSIENT_CONTEXT_RETRY_DELAY_MS = 25;
+var STEALTH_WORLD_NAME = "__opensteer_wait__";
+var FRAME_OWNER_VISIBILITY_FUNCTION = `function() {
+    if (!(this instanceof HTMLElement)) return false;
+
+    var rect = this.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return false;
+    if (
+        rect.bottom <= 0 ||
+        rect.right <= 0 ||
+        rect.top >= window.innerHeight ||
+        rect.left >= window.innerWidth
+    ) {
+        return false;
+    }
+
+    var style = window.getComputedStyle(this);
+    if (
+        style.display === 'none' ||
+        style.visibility === 'hidden' ||
+        Number(style.opacity) === 0
+    ) {
+        return false;
+    }
+
+    return true;
+}`;
+async function waitForCdpVisualStability(cdp, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_VISUAL_STABILITY_TIMEOUT_MS;
+  const settleMs = options.settleMs ?? DEFAULT_VISUAL_STABILITY_SETTLE_MS;
+  const scope = options.scope ?? "main-frame";
+  if (timeoutMs <= 0) {
+    return;
+  }
+  const runtime = new StealthCdpRuntime(cdp);
+  if (scope === "visible-frames") {
+    await runtime.waitForVisibleFramesVisualStability(timeoutMs, settleMs);
+    return;
+  }
+  await runtime.waitForMainFrameVisualStability(timeoutMs, settleMs);
+}
+function buildStabilityScript(timeout, settleMs) {
+  return `new Promise(function(resolve) {
+    var deadline = Date.now() + ${timeout};
+    var resolved = false;
+    var timer = null;
+    var observers = [];
+    var observedShadowRoots = [];
+    var fonts = document.fonts;
+    var fontsReady = !fonts || fonts.status === 'loaded';
+    var lastRelevantMutationAt = Date.now();
+
+    function clearObservers() {
+        for (var i = 0; i < observers.length; i++) {
+            observers[i].disconnect();
+        }
+        observers = [];
+    }
+
+    function done() {
+        if (resolved) return;
+        resolved = true;
+        if (timer) clearTimeout(timer);
+        if (safetyTimer) clearTimeout(safetyTimer);
+        clearObservers();
+        resolve();
+    }
+
+    function isElementVisiblyIntersectingViewport(element) {
+        if (!(element instanceof Element)) return false;
+
+        var rect = element.getBoundingClientRect();
+        var inViewport =
+            rect.width > 0 &&
+            rect.height > 0 &&
+            rect.bottom > 0 &&
+            rect.right > 0 &&
+            rect.top < window.innerHeight &&
+            rect.left < window.innerWidth;
+
+        if (!inViewport) return false;
+
+        var style = window.getComputedStyle(element);
+        if (style.visibility === 'hidden' || style.display === 'none') {
+            return false;
+        }
+        if (Number(style.opacity) === 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    function resolveRelevantElement(node) {
+        if (!node) return null;
+        if (node instanceof Element) return node;
+        if (typeof ShadowRoot !== 'undefined' && node instanceof ShadowRoot) {
+            return node.host instanceof Element ? node.host : null;
+        }
+        var parentElement = node.parentElement;
+        return parentElement instanceof Element ? parentElement : null;
+    }
+
+    function isNodeVisiblyRelevant(node) {
+        var element = resolveRelevantElement(node);
+        if (!element) return false;
+        return isElementVisiblyIntersectingViewport(element);
+    }
+
+    function hasRelevantMutation(records) {
+        for (var i = 0; i < records.length; i++) {
+            var record = records[i];
+            if (isNodeVisiblyRelevant(record.target)) return true;
+
+            var addedNodes = record.addedNodes;
+            for (var j = 0; j < addedNodes.length; j++) {
+                if (isNodeVisiblyRelevant(addedNodes[j])) return true;
+            }
+
+            var removedNodes = record.removedNodes;
+            for (var k = 0; k < removedNodes.length; k++) {
+                if (isNodeVisiblyRelevant(removedNodes[k])) return true;
+            }
+        }
+
+        return false;
+    }
+
+    function scheduleCheck() {
+        if (resolved) return;
+        if (timer) clearTimeout(timer);
+
+        var remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            done();
+            return;
+        }
+
+        var checkDelay = Math.min(120, Math.max(16, ${settleMs}));
+        timer = setTimeout(checkNow, checkDelay);
+    }
+
+    function observeMutations(target) {
+        if (!target) return;
+        var observer = new MutationObserver(function(records) {
+            if (!hasRelevantMutation(records)) return;
+            lastRelevantMutationAt = Date.now();
+            scheduleCheck();
+        });
+        observer.observe(target, {
+            childList: true,
+            subtree: true,
+            attributes: true,
+            characterData: true
+        });
+        observers.push(observer);
+    }
+
+    function hasObservedShadowRoot(root) {
+        for (var i = 0; i < observedShadowRoots.length; i++) {
+            if (observedShadowRoots[i] === root) return true;
+        }
+        return false;
+    }
+
+    function observeOpenShadowRoots() {
+        if (!document.documentElement || !document.createTreeWalker) return;
+        var walker = document.createTreeWalker(
+            document.documentElement,
+            NodeFilter.SHOW_ELEMENT
+        );
+        while (walker.nextNode()) {
+            var current = walker.currentNode;
+            if (!(current instanceof Element)) continue;
+            var shadowRoot = current.shadowRoot;
+            if (!shadowRoot || shadowRoot.mode !== 'open') continue;
+            if (hasObservedShadowRoot(shadowRoot)) continue;
+            observedShadowRoots.push(shadowRoot);
+            observeMutations(shadowRoot);
+        }
+    }
+
+    function checkViewportImages(root) {
+        var images = root.querySelectorAll('img');
+        for (var i = 0; i < images.length; i++) {
+            var img = images[i];
+            if (!isElementVisiblyIntersectingViewport(img)) continue;
+            if (!img.complete) return false;
+        }
+        return true;
+    }
+
+    function getAnimationTarget(effect) {
+        if (!effect) return null;
+        var target = effect.target;
+        if (target instanceof Element) return target;
+
+        if (target && target.element instanceof Element) {
+            return target.element;
+        }
+
+        return null;
+    }
+
+    function hasRunningVisibleFiniteAnimations() {
+        if (typeof document.getAnimations !== 'function') return false;
+        var animations = document.getAnimations();
+
+        for (var i = 0; i < animations.length; i++) {
+            var animation = animations[i];
+            if (!animation || animation.playState !== 'running') continue;
+            var effect = animation.effect;
+            if (!effect || typeof effect.getComputedTiming !== 'function') continue;
+            var timing = effect.getComputedTiming();
+            var endTime = timing && typeof timing.endTime === 'number'
+                ? timing.endTime
+                : Number.POSITIVE_INFINITY;
+            if (Number.isFinite(endTime) && endTime > 0) {
+                var target = getAnimationTarget(effect);
+                if (!target) continue;
+                if (!isElementVisiblyIntersectingViewport(target)) continue;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function isVisuallyReady() {
+        if (!fontsReady) return false;
+        if (!checkViewportImages(document)) return false;
+        if (hasRunningVisibleFiniteAnimations()) return false;
+        return true;
+    }
+
+    function checkNow() {
+        if (Date.now() >= deadline) {
+            done();
+            return;
+        }
+
+        observeOpenShadowRoots();
+
+        if (!isVisuallyReady()) {
+            scheduleCheck();
+            return;
+        }
+
+        if (Date.now() - lastRelevantMutationAt >= ${settleMs}) {
+            done();
+            return;
+        }
+
+        scheduleCheck();
+    }
+
+    observeMutations(document.documentElement);
+    observeOpenShadowRoots();
+
+    if (fonts && fonts.ready && typeof fonts.ready.then === 'function') {
+        fonts.ready.then(function() {
+            fontsReady = true;
+            scheduleCheck();
+        }, function() {
+            fontsReady = true;
+            scheduleCheck();
+        });
+    }
+
+    var safetyTimer = setTimeout(done, ${timeout});
+
+    scheduleCheck();
+})`;
+}
+var StealthCdpRuntime = class {
+  constructor(session) {
+    this.session = session;
+  }
+  contextsByFrame = /* @__PURE__ */ new Map();
+  async waitForMainFrameVisualStability(timeoutMs, settleMs) {
+    const frameRecords = await this.getFrameRecords();
+    const mainFrame = frameRecords[0];
+    if (!mainFrame) {
+      return;
+    }
+    await this.waitForFrameVisualStability(mainFrame.frameId, timeoutMs, settleMs, true);
+  }
+  async waitForVisibleFramesVisualStability(timeoutMs, settleMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const remaining = Math.max(0, deadline - Date.now());
+      if (remaining === 0) {
+        return;
+      }
+      const frameIds = await this.collectVisibleFrameIds();
+      if (frameIds.length === 0) {
+        return;
+      }
+      await Promise.all(
+        frameIds.map(async (frameId) => {
+          try {
+            await this.waitForFrameVisualStability(frameId, remaining, settleMs, false);
+          } catch (error) {
+            if (isIgnorableFrameError(error)) {
+              return;
+            }
+            throw error;
+          }
+        })
+      );
+      const currentFrameIds = await this.collectVisibleFrameIds();
+      if (sameFrameIds(frameIds, currentFrameIds)) {
+        return;
+      }
+    }
+  }
+  async getFrameRecords() {
+    const treeResult = await this.session.send("Page.getFrameTree");
+    const records = [];
+    walkFrameTree(treeResult.frameTree, null, records);
+    return records;
+  }
+  async collectVisibleFrameIds() {
+    const frameRecords = await this.getFrameRecords();
+    if (frameRecords.length === 0) {
+      return [];
+    }
+    const visibleFrameIds = [];
+    for (const frameRecord of frameRecords) {
+      if (!frameRecord.parentFrameId) {
+        visibleFrameIds.push(frameRecord.frameId);
+        continue;
+      }
+      try {
+        const parentContextId = await this.ensureFrameContextId(frameRecord.parentFrameId);
+        if (await this.isFrameOwnerVisible(frameRecord.frameId, parentContextId)) {
+          visibleFrameIds.push(frameRecord.frameId);
+        }
+      } catch (error) {
+        if (isIgnorableFrameError(error)) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    return visibleFrameIds;
+  }
+  async ensureFrameContextId(frameId) {
+    const existing = this.contextsByFrame.get(frameId);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const world = await this.session.send("Page.createIsolatedWorld", {
+      frameId,
+      worldName: STEALTH_WORLD_NAME
+    });
+    this.contextsByFrame.set(frameId, world.executionContextId);
+    return world.executionContextId;
+  }
+  async waitForFrameVisualStability(frameId, timeoutMs, settleMs, retryTransientContextErrors) {
+    if (timeoutMs <= 0) {
+      return;
+    }
+    const script = buildStabilityScript(timeoutMs, settleMs);
+    if (!retryTransientContextErrors) {
+      let contextId = await this.ensureFrameContextId(frameId);
+      try {
+        await this.evaluateWithGuard(contextId, script, timeoutMs);
+      } catch (error) {
+        if (!isMissingExecutionContextError(error)) {
+          throw error;
+        }
+        this.contextsByFrame.delete(frameId);
+        contextId = await this.ensureFrameContextId(frameId);
+        await this.evaluateWithGuard(contextId, script, timeoutMs);
+      }
+      return;
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const remaining = Math.max(0, deadline - Date.now());
+      if (remaining === 0) {
+        return;
+      }
+      const contextId = await this.ensureFrameContextId(frameId);
+      try {
+        await this.evaluateWithGuard(contextId, script, remaining);
+        return;
+      } catch (error) {
+        if (!isTransientExecutionContextError(error)) {
+          throw error;
+        }
+        this.contextsByFrame.delete(frameId);
+        await sleep(Math.min(TRANSIENT_CONTEXT_RETRY_DELAY_MS, Math.max(0, deadline - Date.now())));
+      }
+    }
+  }
+  async evaluateWithGuard(contextId, script, timeoutMs) {
+    const guardedPromise = this.evaluateScript(contextId, script).then(() => ({ kind: "resolved" })).catch((error) => ({ kind: "rejected", error }));
+    const timeoutPromise = new Promise((resolve) => {
+      setTimeout(() => resolve({ kind: "timeout" }), timeoutMs + FRAME_EVALUATE_GRACE_MS);
+    });
+    const outcome = await Promise.race([guardedPromise, timeoutPromise]);
+    if (outcome.kind === "rejected") {
+      throw outcome.error;
+    }
+  }
+  async evaluateScript(contextId, script) {
+    const evaluated = await this.session.send("Runtime.evaluate", {
+      contextId,
+      expression: script,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (evaluated.exceptionDetails) {
+      throw new Error(formatCdpException(evaluated.exceptionDetails));
+    }
+  }
+  async isFrameOwnerVisible(frameId, executionContextId) {
+    const frameOwner = await this.session.send("DOM.getFrameOwner", {
+      frameId
+    });
+    if (frameOwner.backendNodeId === void 0) {
+      return false;
+    }
+    const resolved = await this.session.send("DOM.resolveNode", {
+      backendNodeId: frameOwner.backendNodeId,
+      executionContextId
+    });
+    const objectId = resolved.object?.objectId;
+    if (!objectId) {
+      return false;
+    }
+    try {
+      const callResult = await this.session.send("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: FRAME_OWNER_VISIBILITY_FUNCTION,
+        returnByValue: true
+      });
+      if (callResult.exceptionDetails) {
+        throw new Error(formatCdpException(callResult.exceptionDetails));
+      }
+      return callResult.result.value === true;
+    } finally {
+      await this.releaseObject(objectId);
+    }
+  }
+  async releaseObject(objectId) {
+    await this.session.send("Runtime.releaseObject", {
+      objectId
+    }).catch(() => void 0);
+  }
+};
+function walkFrameTree(node, parentFrameId, records) {
+  const frameId = node.frame?.id;
+  if (!frameId) {
+    return;
+  }
+  records.push({
+    frameId,
+    parentFrameId
+  });
+  for (const child of node.childFrames ?? []) {
+    walkFrameTree(child, frameId, records);
+  }
+}
+function sameFrameIds(before, after) {
+  if (before.length !== after.length) {
+    return false;
+  }
+  return before.every((frameId) => after.includes(frameId));
+}
+function formatCdpException(details) {
+  return details.exception?.description || details.text || "CDP runtime evaluation failed.";
+}
+function isIgnorableFrameError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  return message.includes("Frame with the given id was not found") || message.includes("No frame for given id found") || isTransientExecutionContextError(error);
+}
+function isTransientExecutionContextError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  return message.includes("Execution context was destroyed") || message.includes("Cannot find context with specified id") || message.includes("Cannot find execution context");
+}
+function isMissingExecutionContextError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  return message.includes("Cannot find context with specified id") || message.includes("Cannot find execution context");
+}
+function sleep(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { BrowserCoreError, DEFAULT_VISUAL_STABILITY_SETTLE_MS, DEFAULT_VISUAL_STABILITY_TIMEOUT_MS, DOM_SNAPSHOT_COMPUTED_STYLE_NAMES, FakeBrowserCoreEngine, allBrowserCapabilities, bodyPayloadFromUtf8, brand, buildCdpShadowBoundaryIndex, buildDomSnapshotFromCdpCapture, closedPageError, closedSessionError, createBodyPayload, createBrowserCoreError, createChooserRef, createDevicePixelRatio, createDialogRef, createDocumentEpoch, createDocumentRef, createDownloadRef, createFakeBrowserCoreEngine, createFrameRef, createHeaderEntry, createNetworkRequestId, createNodeLocator, createNodeRef, createPageRef, createPageScaleFactor, createPageZoomFactor, createPoint, createQuad, createRect, createScrollOffset, createSessionRef, createSize, createWorkerRef, filterCookieRecords, findDomSnapshotNode, findDomSnapshotNodeByRef, hasCapability, isBrowserCoreError, isChooserRef, isDialogRef, isDocumentRef, isDownloadRef, isFrameRef, isNetworkRequestId, isNodeRef, isPageRef, isSessionRef, isWorkerRef, matchesNetworkRecordFilters, mergeBrowserCapabilities, nextDocumentEpoch, noBrowserCapabilities, normalizeCdpShadowRootType, parseCdpStringTable, quadBounds, rareCdpIntegerValue, rareCdpStringValue, rectContainsPoint, rectToQuad, serializeDocumentEpoch, serializeRef, staleNodeRefError, unsupportedCapabilityError, waitForCdpVisualStability };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map