npm - @opensteer/browser-core - Versions diffs - 0.7.0 - Mend

@opensteer/browser-core 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.cjs ADDED Viewed

@@ -0,0 +1,2914 @@
+'use strict';
+// 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));
+}
+exports.BrowserCoreError = BrowserCoreError;
+exports.DEFAULT_VISUAL_STABILITY_SETTLE_MS = DEFAULT_VISUAL_STABILITY_SETTLE_MS;
+exports.DEFAULT_VISUAL_STABILITY_TIMEOUT_MS = DEFAULT_VISUAL_STABILITY_TIMEOUT_MS;
+exports.DOM_SNAPSHOT_COMPUTED_STYLE_NAMES = DOM_SNAPSHOT_COMPUTED_STYLE_NAMES;
+exports.FakeBrowserCoreEngine = FakeBrowserCoreEngine;
+exports.allBrowserCapabilities = allBrowserCapabilities;
+exports.bodyPayloadFromUtf8 = bodyPayloadFromUtf8;
+exports.brand = brand;
+exports.buildCdpShadowBoundaryIndex = buildCdpShadowBoundaryIndex;
+exports.buildDomSnapshotFromCdpCapture = buildDomSnapshotFromCdpCapture;
+exports.closedPageError = closedPageError;
+exports.closedSessionError = closedSessionError;
+exports.createBodyPayload = createBodyPayload;
+exports.createBrowserCoreError = createBrowserCoreError;
+exports.createChooserRef = createChooserRef;
+exports.createDevicePixelRatio = createDevicePixelRatio;
+exports.createDialogRef = createDialogRef;
+exports.createDocumentEpoch = createDocumentEpoch;
+exports.createDocumentRef = createDocumentRef;
+exports.createDownloadRef = createDownloadRef;
+exports.createFakeBrowserCoreEngine = createFakeBrowserCoreEngine;
+exports.createFrameRef = createFrameRef;
+exports.createHeaderEntry = createHeaderEntry;
+exports.createNetworkRequestId = createNetworkRequestId;
+exports.createNodeLocator = createNodeLocator;
+exports.createNodeRef = createNodeRef;
+exports.createPageRef = createPageRef;
+exports.createPageScaleFactor = createPageScaleFactor;
+exports.createPageZoomFactor = createPageZoomFactor;
+exports.createPoint = createPoint;
+exports.createQuad = createQuad;
+exports.createRect = createRect;
+exports.createScrollOffset = createScrollOffset;
+exports.createSessionRef = createSessionRef;
+exports.createSize = createSize;
+exports.createWorkerRef = createWorkerRef;
+exports.filterCookieRecords = filterCookieRecords;
+exports.findDomSnapshotNode = findDomSnapshotNode;
+exports.findDomSnapshotNodeByRef = findDomSnapshotNodeByRef;
+exports.hasCapability = hasCapability;
+exports.isBrowserCoreError = isBrowserCoreError;
+exports.isChooserRef = isChooserRef;
+exports.isDialogRef = isDialogRef;
+exports.isDocumentRef = isDocumentRef;
+exports.isDownloadRef = isDownloadRef;
+exports.isFrameRef = isFrameRef;
+exports.isNetworkRequestId = isNetworkRequestId;
+exports.isNodeRef = isNodeRef;
+exports.isPageRef = isPageRef;
+exports.isSessionRef = isSessionRef;
+exports.isWorkerRef = isWorkerRef;
+exports.matchesNetworkRecordFilters = matchesNetworkRecordFilters;
+exports.mergeBrowserCapabilities = mergeBrowserCapabilities;
+exports.nextDocumentEpoch = nextDocumentEpoch;
+exports.noBrowserCapabilities = noBrowserCapabilities;
+exports.normalizeCdpShadowRootType = normalizeCdpShadowRootType;
+exports.parseCdpStringTable = parseCdpStringTable;
+exports.quadBounds = quadBounds;
+exports.rareCdpIntegerValue = rareCdpIntegerValue;
+exports.rareCdpStringValue = rareCdpStringValue;
+exports.rectContainsPoint = rectContainsPoint;
+exports.rectToQuad = rectToQuad;
+exports.serializeDocumentEpoch = serializeDocumentEpoch;
+exports.serializeRef = serializeRef;
+exports.staleNodeRefError = staleNodeRefError;
+exports.unsupportedCapabilityError = unsupportedCapabilityError;
+exports.waitForCdpVisualStability = waitForCdpVisualStability;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map