@checkly/playwright-core 1.51.17-beta.2 → 1.54.2-beta.1

package/lib/server/page.js

@@ -1,320 +1,321 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var page_exports = {};
+__export(page_exports, {
+  InitScript: () => InitScript,
+  Page: () => Page,
+  PageBinding: () => PageBinding,
+  Worker: () => Worker
 });
-exports.Worker = exports.PageBinding = exports.Page = exports.InitScript = void 0;
-var accessibility = _interopRequireWildcard(require("./accessibility"));
-var _browserContext = require("./browserContext");
-var _console = require("./console");
-var _errors = require("./errors");
-var _fileChooser = require("./fileChooser");
-var frames = _interopRequireWildcard(require("./frames"));
-var _helper = require("./helper");
-var input = _interopRequireWildcard(require("./input"));
-var _instrumentation = require("./instrumentation");
-var _utilityScriptSerializers = require("./isomorphic/utilityScriptSerializers");
-var js = _interopRequireWildcard(require("./javascript"));
-var _progress = require("./progress");
-var _screenshotter = require("./screenshotter");
-var _timeoutSettings = require("./timeoutSettings");
-var _utils = require("../utils");
-var _crypto = require("./utils/crypto");
-var _comparators = require("./utils/comparators");
-var _debugLogger = require("./utils/debugLogger");
-var _selectorParser = require("../utils/isomorphic/selectorParser");
-var _manualPromise = require("../utils/isomorphic/manualPromise");
-var _callLog = require("./callLog");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-/**
- * Copyright 2017 Google Inc. All rights reserved.
- * Modifications copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class Page extends _instrumentation.SdkObject {
+module.exports = __toCommonJS(page_exports);
+var accessibility = __toESM(require("./accessibility"));
+var import_browserContext = require("./browserContext");
+var import_console = require("./console");
+var import_errors = require("./errors");
+var import_fileChooser = require("./fileChooser");
+var frames = __toESM(require("./frames"));
+var import_helper = require("./helper");
+var input = __toESM(require("./input"));
+var import_instrumentation = require("./instrumentation");
+var js = __toESM(require("./javascript"));
+var import_screenshotter = require("./screenshotter");
+var import_utils = require("../utils");
+var import_utils2 = require("../utils");
+var import_comparators = require("./utils/comparators");
+var import_debugLogger = require("./utils/debugLogger");
+var import_selectorParser = require("../utils/isomorphic/selectorParser");
+var import_manualPromise = require("../utils/isomorphic/manualPromise");
+var import_utilityScriptSerializers = require("../utils/isomorphic/utilityScriptSerializers");
+var import_callLog = require("./callLog");
+var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
+class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
-    super(browserContext, 'page');
-    this._closedState = 'open';
-    this._closedPromise = new _manualPromise.ManualPromise();
-    this._initialized = void 0;
-    this._initializedPromise = new _manualPromise.ManualPromise();
+    super(browserContext, "page");
+    this._closedState = "open";
+    this._closedPromise = new import_manualPromise.ManualPromise();
+    this._initializedPromise = new import_manualPromise.ManualPromise();
     this._eventsToEmitAfterInitialized = [];
     this._crashed = false;
-    this.openScope = new _utils.LongStandingScope();
-    this._browserContext = void 0;
-    this.keyboard = void 0;
-    this.mouse = void 0;
-    this.touchscreen = void 0;
-    this._timeoutSettings = void 0;
-    this._delegate = void 0;
-    this._emulatedSize = void 0;
-    this._extraHTTPHeaders = void 0;
+    this.openScope = new import_utils.LongStandingScope();
     this._emulatedMedia = {};
-    this._interceptFileChooser = false;
-    this._pageBindings = new Map();
+    this._fileChooserInterceptedBy = /* @__PURE__ */ new Set();
+    this._pageBindings = /* @__PURE__ */ new Map();
     this.initScripts = [];
-    this._screenshotter = void 0;
-    this._frameManager = void 0;
-    this.accessibility = void 0;
-    this._workers = new Map();
-    this.pdf = void 0;
-    this.coverage = void 0;
-    this._clientRequestInterceptor = void 0;
-    this._serverRequestInterceptor = void 0;
-    this._ownedContext = void 0;
-    this._video = null;
-    this._opener = void 0;
+    this._workers = /* @__PURE__ */ new Map();
+    this.requestInterceptors = [];
+    this.video = null;
     this._isServerSideOnly = false;
-    this._locatorHandlers = new Map();
+    this._locatorHandlers = /* @__PURE__ */ new Map();
     this._lastLocatorHandlerUid = 0;
     this._locatorHandlerRunningCounter = 0;
     // Aiming at 25 fps by default - each frame is 40ms, but we give some slack with 35ms.
     // When throttling for tracing, 200ms between frames, except for 10 frames around the action.
     this._frameThrottler = new FrameThrottler(10, 35, 200);
-    this._closeReason = void 0;
+    this.lastSnapshotFrameIds = [];
     this.attribution.page = this;
-    this._delegate = delegate;
-    this._browserContext = browserContext;
+    this.delegate = delegate;
+    this.browserContext = browserContext;
     this.accessibility = new accessibility.Accessibility(delegate.getAccessibilityTree.bind(delegate));
-    this.keyboard = new input.Keyboard(delegate.rawKeyboard);
+    this.keyboard = new input.Keyboard(delegate.rawKeyboard, this);
     this.mouse = new input.Mouse(delegate.rawMouse, this);
     this.touchscreen = new input.Touchscreen(delegate.rawTouchscreen, this);
-    this._timeoutSettings = new _timeoutSettings.TimeoutSettings(browserContext._timeoutSettings);
-    this._screenshotter = new _screenshotter.Screenshotter(this);
-    this._frameManager = new frames.FrameManager(this);
-    if (delegate.pdf) this.pdf = delegate.pdf.bind(delegate);
+    this.screenshotter = new import_screenshotter.Screenshotter(this);
+    this.frameManager = new frames.FrameManager(this);
+    if (delegate.pdf)
+      this.pdf = delegate.pdf.bind(delegate);
     this.coverage = delegate.coverage ? delegate.coverage() : null;
   }
-  async reportAsNew(opener, error = undefined, contextEvent = _browserContext.BrowserContext.Events.Page) {
+  static {
+    this.Events = {
+      Close: "close",
+      Crash: "crash",
+      Download: "download",
+      EmulatedSizeChanged: "emulatedsizechanged",
+      FileChooser: "filechooser",
+      FrameAttached: "frameattached",
+      FrameDetached: "framedetached",
+      InternalFrameNavigatedToNewDocument: "internalframenavigatedtonewdocument",
+      LocatorHandlerTriggered: "locatorhandlertriggered",
+      ScreencastFrame: "screencastframe",
+      Video: "video",
+      WebSocket: "websocket",
+      Worker: "worker"
+    };
+  }
+  async reportAsNew(opener, error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
     if (opener) {
       const openerPageOrError = await opener.waitForInitializedOrError();
-      if (openerPageOrError instanceof Page && !openerPageOrError.isClosed()) this._opener = openerPageOrError;
+      if (openerPageOrError instanceof Page && !openerPageOrError.isClosed())
+        this._opener = openerPageOrError;
     }
     this._markInitialized(error, contextEvent);
   }
-  _markInitialized(error = undefined, contextEvent = _browserContext.BrowserContext.Events.Page) {
+  _markInitialized(error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
     if (error) {
-      // Initialization error could have happened because of
-      // context/browser closure. Just ignore the page.
-      if (this._browserContext.isClosingOrClosed()) return;
-      this._frameManager.createDummyMainFrameIfNeeded();
+      if (this.browserContext.isClosingOrClosed())
+        return;
+      this.frameManager.createDummyMainFrameIfNeeded();
     }
     this._initialized = error || this;
     this.emitOnContext(contextEvent, this);
-    for (const {
-      event,
-      args
-    } of this._eventsToEmitAfterInitialized) this._browserContext.emit(event, ...args);
+    for (const { event, args } of this._eventsToEmitAfterInitialized)
+      this.browserContext.emit(event, ...args);
     this._eventsToEmitAfterInitialized = [];
-
-    // It may happen that page initialization finishes after Close event has already been sent,
-    // in that case we fire another Close event to ensure that each reported Page will have
-    // corresponding Close event after it is reported on the context.
-    if (this.isClosed()) this.emit(Page.Events.Close);else this.instrumentation.onPageOpen(this);
-
-    // Note: it is important to resolve _initializedPromise at the end,
-    // so that anyone who awaits waitForInitializedOrError got a ready and reported page.
+    if (this.isClosed())
+      this.emit(Page.Events.Close);
+    else
+      this.instrumentation.onPageOpen(this);
     this._initializedPromise.resolve(this._initialized);
   }
   initializedOrUndefined() {
-    return this._initialized ? this : undefined;
+    return this._initialized ? this : void 0;
   }
   waitForInitializedOrError() {
     return this._initializedPromise;
   }
   emitOnContext(event, ...args) {
-    if (this._isServerSideOnly) return;
-    this._browserContext.emit(event, ...args);
+    if (this._isServerSideOnly)
+      return;
+    this.browserContext.emit(event, ...args);
   }
   emitOnContextOnceInitialized(event, ...args) {
-    if (this._isServerSideOnly) return;
-    // Some events, like console messages, may come before page is ready.
-    // In this case, postpone the event until page is initialized,
-    // and dispatch it to the client later, either on the live Page,
-    // or on the "errored" Page.
-    if (this._initialized) this._browserContext.emit(event, ...args);else this._eventsToEmitAfterInitialized.push({
-      event,
-      args
-    });
+    if (this._isServerSideOnly)
+      return;
+    if (this._initialized)
+      this.browserContext.emit(event, ...args);
+    else
+      this._eventsToEmitAfterInitialized.push({ event, args });
   }
-  async resetForReuse(metadata) {
-    this.setDefaultNavigationTimeout(undefined);
-    this.setDefaultTimeout(undefined);
-    this._locatorHandlers.clear();
-    await this._removeExposedBindings();
-    await this._removeInitScripts();
-    await this.setClientRequestInterceptor(undefined);
-    await this._setServerRequestInterceptor(undefined);
-    await this.setFileChooserIntercepted(false);
-    // Re-navigate once init scripts are gone.
-    await this.mainFrame().goto(metadata, 'about:blank');
-    this._emulatedSize = undefined;
+  async resetForReuse(progress) {
+    await this.mainFrame().gotoImpl(progress, "about:blank", {});
+    this._emulatedSize = void 0;
     this._emulatedMedia = {};
-    this._extraHTTPHeaders = undefined;
-    this._interceptFileChooser = false;
-    await Promise.all([this._delegate.updateEmulatedViewportSize(), this._delegate.updateEmulateMedia(), this._delegate.updateFileChooserInterception()]);
-    await this._delegate.resetForReuse();
+    this._extraHTTPHeaders = void 0;
+    await Promise.all([
+      this.delegate.updateEmulatedViewportSize(),
+      this.delegate.updateEmulateMedia(),
+      this.delegate.updateExtraHTTPHeaders()
+    ]);
+    await this.delegate.resetForReuse(progress);
   }
   _didClose() {
-    this._frameManager.dispose();
+    this.frameManager.dispose();
     this._frameThrottler.dispose();
-    (0, _utils.assert)(this._closedState !== 'closed', 'Page closed twice');
-    this._closedState = 'closed';
+    (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
+    this._closedState = "closed";
     this.emit(Page.Events.Close);
     this._closedPromise.resolve();
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new _errors.TargetClosedError());
+    this.openScope.close(new import_errors.TargetClosedError());
   }
   _didCrash() {
-    this._frameManager.dispose();
+    this.frameManager.dispose();
     this._frameThrottler.dispose();
     this.emit(Page.Events.Crash);
     this._crashed = true;
     this.instrumentation.onPageClose(this);
-    this.openScope.close(new Error('Page crashed'));
+    this.openScope.close(new Error("Page crashed"));
   }
   async _onFileChooserOpened(handle) {
     let multiple;
     try {
-      multiple = await handle.evaluate(element => !!element.multiple);
+      multiple = await handle.evaluate((element) => !!element.multiple);
     } catch (e) {
-      // Frame/context may be gone during async processing. Do not throw.
       return;
     }
     if (!this.listenerCount(Page.Events.FileChooser)) {
       handle.dispose();
       return;
     }
-    const fileChooser = new _fileChooser.FileChooser(this, handle, multiple);
+    const fileChooser = new import_fileChooser.FileChooser(this, handle, multiple);
     this.emit(Page.Events.FileChooser, fileChooser);
   }
-  context() {
-    return this._browserContext;
-  }
   opener() {
     return this._opener;
   }
   mainFrame() {
-    return this._frameManager.mainFrame();
+    return this.frameManager.mainFrame();
   }
   frames() {
-    return this._frameManager.frames();
-  }
-  setDefaultNavigationTimeout(timeout) {
-    this._timeoutSettings.setDefaultNavigationTimeout(timeout);
-  }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  async exposeBinding(name, needsHandle, playwrightBinding) {
-    if (this._pageBindings.has(name)) throw new Error(`Function "${name}" has been already registered`);
-    if (this._browserContext._pageBindings.has(name)) throw new Error(`Function "${name}" has been already registered in the browser context`);
+    return this.frameManager.frames();
+  }
+  async exposeBinding(progress, name, needsHandle, playwrightBinding) {
+    if (this._pageBindings.has(name))
+      throw new Error(`Function "${name}" has been already registered`);
+    if (this.browserContext._pageBindings.has(name))
+      throw new Error(`Function "${name}" has been already registered in the browser context`);
+    await progress.race(this.browserContext.exposePlaywrightBindingIfNeeded());
     const binding = new PageBinding(name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    await this._delegate.addInitScript(binding.initScript);
-    await Promise.all(this.frames().map(frame => frame.evaluateExpression(binding.initScript.source).catch(e => {})));
-  }
-  async _removeExposedBindings() {
-    for (const [key, binding] of this._pageBindings) {
-      if (!binding.internal) this._pageBindings.delete(key);
-    }
-  }
-  setExtraHTTPHeaders(headers) {
+    progress.cleanupWhenAborted(() => this._pageBindings.delete(name));
+    await progress.race(this.delegate.addInitScript(binding.initScript));
+    await progress.race(this.safeNonStallingEvaluateInAllFrames(binding.initScript.source, "main"));
+    return binding;
+  }
+  async removeExposedBindings(bindings) {
+    bindings = bindings.filter((binding) => this._pageBindings.get(binding.name) === binding);
+    for (const binding of bindings)
+      this._pageBindings.delete(binding.name);
+    await this.delegate.removeInitScripts(bindings.map((binding) => binding.initScript));
+    const cleanup = bindings.map((binding) => `{ ${binding.cleanupScript} };
+`).join("");
+    await this.safeNonStallingEvaluateInAllFrames(cleanup, "main");
+  }
+  async setExtraHTTPHeaders(progress, headers) {
+    const oldHeaders = this._extraHTTPHeaders;
     this._extraHTTPHeaders = headers;
-    return this._delegate.updateExtraHTTPHeaders();
+    progress.cleanupWhenAborted(async () => {
+      this._extraHTTPHeaders = oldHeaders;
+      await this.delegate.updateExtraHTTPHeaders();
+    });
+    await progress.race(this.delegate.updateExtraHTTPHeaders());
   }
   extraHTTPHeaders() {
     return this._extraHTTPHeaders;
   }
-  async _onBindingCalled(payload, context) {
-    if (this._closedState === 'closed') return;
+  async onBindingCalled(payload, context) {
+    if (this._closedState === "closed")
+      return;
     await PageBinding.dispatch(this, payload, context);
   }
-  _addConsoleMessage(type, args, location, text) {
-    const message = new _console.ConsoleMessage(this, type, text, args, location);
-    const intercepted = this._frameManager.interceptConsoleMessage(message);
+  addConsoleMessage(type, args, location, text) {
+    const message = new import_console.ConsoleMessage(this, type, text, args, location);
+    const intercepted = this.frameManager.interceptConsoleMessage(message);
     if (intercepted) {
-      args.forEach(arg => arg.dispose());
+      args.forEach((arg) => arg.dispose());
       return;
     }
-    this.emitOnContextOnceInitialized(_browserContext.BrowserContext.Events.Console, message);
+    this.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.Console, message);
   }
-  async reload(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to reload(),
-      // so we should await it immediately.
+  async reload(progress, options) {
+    return this.mainFrame().raceNavigationAction(progress, async () => {
       const [response] = await Promise.all([
-      // Reload must be a new document, and should not be confused with a stray pushState.
-      this.mainFrame()._waitForNavigation(progress, true /* requiresNewDocument */, options), this._delegate.reload()]);
+        // Reload must be a new document, and should not be confused with a stray pushState.
+        this.mainFrame()._waitForNavigation(progress, true, options),
+        progress.race(this.delegate.reload())
+      ]);
       return response;
-    }), this._timeoutSettings.navigationTimeout(options));
+    });
   }
-  async goBack(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to goBack,
-      // so we should catch it immediately.
+  async goBack(progress, options) {
+    return this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
+      const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this._delegate.goBack();
-      if (!result) return null;
+      const result = await progress.race(this.delegate.goBack());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
+        return null;
+      }
       const response = await waitPromise;
-      if (error) throw error;
+      if (error)
+        throw error;
       return response;
-    }), this._timeoutSettings.navigationTimeout(options));
+    });
   }
-  async goForward(metadata, options) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this.mainFrame().raceNavigationAction(progress, options, async () => {
-      // Note: waitForNavigation may fail before we get response to goForward,
-      // so we should catch it immediately.
+  async goForward(progress, options) {
+    return this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
-      const waitPromise = this.mainFrame()._waitForNavigation(progress, false /* requiresNewDocument */, options).catch(e => {
+      const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this._delegate.goForward();
-      if (!result) return null;
+      const result = await progress.race(this.delegate.goForward());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
+        return null;
+      }
       const response = await waitPromise;
-      if (error) throw error;
+      if (error)
+        throw error;
       return response;
-    }), this._timeoutSettings.navigationTimeout(options));
+    });
   }
   requestGC() {
-    return this._delegate.requestGC();
+    return this.delegate.requestGC();
   }
   registerLocatorHandler(selector, noWaitAfter) {
     const uid = ++this._lastLocatorHandlerUid;
-    this._locatorHandlers.set(uid, {
-      selector,
-      noWaitAfter
-    });
+    this._locatorHandlers.set(uid, { selector, noWaitAfter });
     return uid;
   }
   resolveLocatorHandler(uid, remove) {
     const handler = this._locatorHandlers.get(uid);
-    if (remove) this._locatorHandlers.delete(uid);
+    if (remove)
+      this._locatorHandlers.delete(uid);
     if (handler) {
-      var _handler$resolved;
-      (_handler$resolved = handler.resolved) === null || _handler$resolved === void 0 || _handler$resolved.resolve();
-      handler.resolved = undefined;
+      handler.resolved?.resolve();
+      handler.resolved = void 0;
     }
   }
   unregisterLocatorHandler(uid) {
@@ -322,502 +323,418 @@ class Page extends _instrumentation.SdkObject {
   }
   async performActionPreChecks(progress) {
     await this._performWaitForNavigationCheck(progress);
-    progress.throwIfAborted();
     await this._performLocatorHandlersCheckpoint(progress);
-    progress.throwIfAborted();
-    // Wait once again, just in case a locator handler caused a navigation.
     await this._performWaitForNavigationCheck(progress);
   }
   async _performWaitForNavigationCheck(progress) {
-    var _mainFrame$pendingDoc;
-    if (process.env.PLAYWRIGHT_SKIP_NAVIGATION_CHECK) return;
-    const mainFrame = this._frameManager.mainFrame();
-    if (!mainFrame || !mainFrame.pendingDocument()) return;
-    const url = (_mainFrame$pendingDoc = mainFrame.pendingDocument()) === null || _mainFrame$pendingDoc === void 0 || (_mainFrame$pendingDoc = _mainFrame$pendingDoc.request) === null || _mainFrame$pendingDoc === void 0 ? void 0 : _mainFrame$pendingDoc.url();
-    const toUrl = url ? `" ${(0, _utils.trimStringWithEllipsis)(url, 200)}"` : '';
+    const mainFrame = this.frameManager.mainFrame();
+    if (!mainFrame || !mainFrame.pendingDocument())
+      return;
+    const url = mainFrame.pendingDocument()?.request?.url();
+    const toUrl = url ? `" ${(0, import_utils.trimStringWithEllipsis)(url, 200)}"` : "";
     progress.log(`  waiting for${toUrl} navigation to finish...`);
-    await _helper.helper.waitForEvent(progress, mainFrame, frames.Frame.Events.InternalNavigation, e => {
-      if (!e.isPublic) return false;
-      if (!e.error) progress.log(`  navigated to "${(0, _utils.trimStringWithEllipsis)(mainFrame.url(), 200)}"`);
+    await import_helper.helper.waitForEvent(progress, mainFrame, frames.Frame.Events.InternalNavigation, (e) => {
+      if (!e.isPublic)
+        return false;
+      if (!e.error)
+        progress.log(`  navigated to "${(0, import_utils.trimStringWithEllipsis)(mainFrame.url(), 200)}"`);
       return true;
     }).promise;
   }
   async _performLocatorHandlersCheckpoint(progress) {
-    // Do not run locator handlers from inside locator handler callbacks to avoid deadlocks.
-    if (this._locatorHandlerRunningCounter) return;
+    if (this._locatorHandlerRunningCounter)
+      return;
     for (const [uid, handler] of this._locatorHandlers) {
       if (!handler.resolved) {
-        if (await this.mainFrame().isVisibleInternal(handler.selector, {
-          strict: true
-        })) {
-          handler.resolved = new _manualPromise.ManualPromise();
+        if (await this.mainFrame().isVisibleInternal(progress, handler.selector, { strict: true })) {
+          handler.resolved = new import_manualPromise.ManualPromise();
           this.emit(Page.Events.LocatorHandlerTriggered, uid);
         }
       }
       if (handler.resolved) {
         ++this._locatorHandlerRunningCounter;
-        progress.log(`  found ${(0, _utils.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)}, intercepting action to run the handler`);
+        progress.log(`  found ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)}, intercepting action to run the handler`);
         const promise = handler.resolved.then(async () => {
-          progress.throwIfAborted();
           if (!handler.noWaitAfter) {
-            progress.log(`  locator handler has finished, waiting for ${(0, _utils.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)} to be hidden`);
-            await this.mainFrame().waitForSelectorInternal(progress, handler.selector, false, {
-              state: 'hidden'
-            });
+            progress.log(`  locator handler has finished, waiting for ${(0, import_utils2.asLocator)(this.browserContext._browser.sdkLanguage(), handler.selector)} to be hidden`);
+            await this.mainFrame().waitForSelector(progress, handler.selector, false, { state: "hidden" });
           } else {
             progress.log(`  locator handler has finished`);
           }
         });
-        await this.openScope.race(promise).finally(() => --this._locatorHandlerRunningCounter);
-        // Avoid side-effects after long-running operation.
-        progress.throwIfAborted();
+        await progress.race(this.openScope.race(promise)).finally(() => --this._locatorHandlerRunningCounter);
         progress.log(`  interception handler has finished, continuing`);
       }
     }
   }
-  async emulateMedia(options) {
-    if (options.media !== undefined) this._emulatedMedia.media = options.media;
-    if (options.colorScheme !== undefined) this._emulatedMedia.colorScheme = options.colorScheme;
-    if (options.reducedMotion !== undefined) this._emulatedMedia.reducedMotion = options.reducedMotion;
-    if (options.forcedColors !== undefined) this._emulatedMedia.forcedColors = options.forcedColors;
-    if (options.contrast !== undefined) this._emulatedMedia.contrast = options.contrast;
-    await this._delegate.updateEmulateMedia();
+  async emulateMedia(progress, options) {
+    const oldEmulatedMedia = { ...this._emulatedMedia };
+    progress.cleanupWhenAborted(async () => {
+      this._emulatedMedia = oldEmulatedMedia;
+      await this.delegate.updateEmulateMedia();
+    });
+    if (options.media !== void 0)
+      this._emulatedMedia.media = options.media;
+    if (options.colorScheme !== void 0)
+      this._emulatedMedia.colorScheme = options.colorScheme;
+    if (options.reducedMotion !== void 0)
+      this._emulatedMedia.reducedMotion = options.reducedMotion;
+    if (options.forcedColors !== void 0)
+      this._emulatedMedia.forcedColors = options.forcedColors;
+    if (options.contrast !== void 0)
+      this._emulatedMedia.contrast = options.contrast;
+    await progress.race(this.delegate.updateEmulateMedia());
   }
   emulatedMedia() {
-    var _contextOptions$color, _contextOptions$reduc, _contextOptions$force, _contextOptions$contr;
-    const contextOptions = this._browserContext._options;
+    const contextOptions = this.browserContext._options;
     return {
-      media: this._emulatedMedia.media || 'no-override',
-      colorScheme: this._emulatedMedia.colorScheme !== undefined ? this._emulatedMedia.colorScheme : (_contextOptions$color = contextOptions.colorScheme) !== null && _contextOptions$color !== void 0 ? _contextOptions$color : 'light',
-      reducedMotion: this._emulatedMedia.reducedMotion !== undefined ? this._emulatedMedia.reducedMotion : (_contextOptions$reduc = contextOptions.reducedMotion) !== null && _contextOptions$reduc !== void 0 ? _contextOptions$reduc : 'no-preference',
-      forcedColors: this._emulatedMedia.forcedColors !== undefined ? this._emulatedMedia.forcedColors : (_contextOptions$force = contextOptions.forcedColors) !== null && _contextOptions$force !== void 0 ? _contextOptions$force : 'none',
-      contrast: this._emulatedMedia.contrast !== undefined ? this._emulatedMedia.contrast : (_contextOptions$contr = contextOptions.contrast) !== null && _contextOptions$contr !== void 0 ? _contextOptions$contr : 'no-preference'
+      media: this._emulatedMedia.media || "no-override",
+      colorScheme: this._emulatedMedia.colorScheme !== void 0 ? this._emulatedMedia.colorScheme : contextOptions.colorScheme ?? "light",
+      reducedMotion: this._emulatedMedia.reducedMotion !== void 0 ? this._emulatedMedia.reducedMotion : contextOptions.reducedMotion ?? "no-preference",
+      forcedColors: this._emulatedMedia.forcedColors !== void 0 ? this._emulatedMedia.forcedColors : contextOptions.forcedColors ?? "none",
+      contrast: this._emulatedMedia.contrast !== void 0 ? this._emulatedMedia.contrast : contextOptions.contrast ?? "no-preference"
     };
   }
-  async setViewportSize(viewportSize) {
-    this._emulatedSize = {
-      viewport: {
-        ...viewportSize
-      },
-      screen: {
-        ...viewportSize
-      }
-    };
-    await this._delegate.updateEmulatedViewportSize();
+  async setViewportSize(progress, viewportSize) {
+    const oldEmulatedSize = this._emulatedSize;
+    progress.cleanupWhenAborted(async () => {
+      this._emulatedSize = oldEmulatedSize;
+      await this.delegate.updateEmulatedViewportSize();
+    });
+    this._setEmulatedSize({ viewport: { ...viewportSize }, screen: { ...viewportSize } });
+    await progress.race(this.delegate.updateEmulatedViewportSize());
+  }
+  setEmulatedSizeFromWindowOpen(emulatedSize) {
+    this._setEmulatedSize(emulatedSize);
   }
-  viewportSize() {
-    var _this$emulatedSize;
-    return ((_this$emulatedSize = this.emulatedSize()) === null || _this$emulatedSize === void 0 ? void 0 : _this$emulatedSize.viewport) || null;
+  _setEmulatedSize(emulatedSize) {
+    this._emulatedSize = emulatedSize;
+    this.emit(Page.Events.EmulatedSizeChanged);
   }
   emulatedSize() {
-    if (this._emulatedSize) return this._emulatedSize;
-    const contextOptions = this._browserContext._options;
-    return contextOptions.viewport ? {
-      viewport: contextOptions.viewport,
-      screen: contextOptions.screen || contextOptions.viewport
-    } : null;
+    if (this._emulatedSize)
+      return this._emulatedSize;
+    const contextOptions = this.browserContext._options;
+    return contextOptions.viewport ? { viewport: contextOptions.viewport, screen: contextOptions.screen || contextOptions.viewport } : void 0;
   }
   async bringToFront() {
-    await this._delegate.bringToFront();
+    await this.delegate.bringToFront();
   }
-  async addInitScript(source, name) {
-    const initScript = new InitScript(source, false /* internal */, name);
+  async addInitScript(progress, source) {
+    const initScript = new InitScript(source);
     this.initScripts.push(initScript);
-    await this._delegate.addInitScript(initScript);
+    progress.cleanupWhenAborted(() => this.removeInitScripts([initScript]));
+    await progress.race(this.delegate.addInitScript(initScript));
+    return initScript;
   }
-  async _removeInitScripts() {
-    this.initScripts = this.initScripts.filter(script => script.internal);
-    await this._delegate.removeNonInternalInitScripts();
+  async removeInitScripts(initScripts) {
+    const set = new Set(initScripts);
+    this.initScripts = this.initScripts.filter((script) => !set.has(script));
+    await this.delegate.removeInitScripts(initScripts);
   }
   needsRequestInterception() {
-    return !!this._clientRequestInterceptor || !!this._serverRequestInterceptor || !!this._browserContext._requestInterceptor;
-  }
-  async setClientRequestInterceptor(handler) {
-    this._clientRequestInterceptor = handler;
-    await this._delegate.updateRequestInterception();
-  }
-  async _setServerRequestInterceptor(handler) {
-    this._serverRequestInterceptor = handler;
-    await this._delegate.updateRequestInterception();
+    return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
+  }
+  async addRequestInterceptor(progress, handler, prepend) {
+    if (prepend)
+      this.requestInterceptors.unshift(handler);
+    else
+      this.requestInterceptors.push(handler);
+    await this.delegate.updateRequestInterception();
+  }
+  async removeRequestInterceptor(handler) {
+    const index = this.requestInterceptors.indexOf(handler);
+    if (index === -1)
+      return;
+    this.requestInterceptors.splice(index, 1);
+    await this.browserContext.notifyRoutesInFlightAboutRemovedHandler(handler);
+    await this.delegate.updateRequestInterception();
   }
-  async expectScreenshot(metadata, options = {}) {
+  async expectScreenshot(progress, options) {
     const locator = options.locator;
-    const rafrafScreenshot = locator ? async (progress, timeout) => {
+    const rafrafScreenshot = locator ? async (timeout) => {
       return await locator.frame.rafrafTimeoutScreenshotElementWithProgress(progress, locator.selector, timeout, options || {});
-    } : async (progress, timeout) => {
+    } : async (timeout) => {
       await this.performActionPreChecks(progress);
-      await this.mainFrame().rafrafTimeout(timeout);
-      return await this._screenshotter.screenshotPage(progress, options || {});
-    };
-    const comparator = (0, _comparators.getComparator)('image/png');
-    const controller = new _progress.ProgressController(metadata, this);
-    if (!options.expected && options.isNot) return {
-      errorMessage: '"not" matcher requires expected result'
+      await this.mainFrame().rafrafTimeout(progress, timeout);
+      return await this.screenshotter.screenshotPage(progress, options || {});
     };
+    const comparator = (0, import_comparators.getComparator)("image/png");
+    if (!options.expected && options.isNot)
+      return { errorMessage: '"not" matcher requires expected result' };
     try {
-      const format = (0, _screenshotter.validateScreenshotOptions)(options || {});
-      if (format !== 'png') throw new Error('Only PNG screenshots are supported');
+      const format = (0, import_screenshotter.validateScreenshotOptions)(options || {});
+      if (format !== "png")
+        throw new Error("Only PNG screenshots are supported");
     } catch (error) {
-      return {
-        errorMessage: error.message
-      };
+      return { errorMessage: error.message };
     }
-    let intermediateResult = undefined;
+    let intermediateResult;
     const areEqualScreenshots = (actual, expected, previous) => {
-      const comparatorResult = actual && expected ? comparator(actual, expected, options) : undefined;
-      if (comparatorResult !== undefined && !!comparatorResult === !!options.isNot) return true;
-      if (comparatorResult) intermediateResult = {
-        errorMessage: comparatorResult.errorMessage,
-        diff: comparatorResult.diff,
-        actual,
-        previous
-      };
+      const comparatorResult = actual && expected ? comparator(actual, expected, options) : void 0;
+      if (comparatorResult !== void 0 && !!comparatorResult === !!options.isNot)
+        return true;
+      if (comparatorResult)
+        intermediateResult = { errorMessage: comparatorResult.errorMessage, diff: comparatorResult.diff, actual, previous };
       return false;
     };
-    const callTimeout = this._timeoutSettings.timeout(options);
-    return controller.run(async progress => {
+    const handleError = (e) => {
+      if (js.isJavaScriptErrorInEvaluate(e) || (0, import_selectorParser.isInvalidSelectorError)(e))
+        throw e;
+      let errorMessage = e.message;
+      if (e instanceof import_errors.TimeoutError && intermediateResult?.previous)
+        errorMessage = `Failed to take two consecutive stable screenshots.`;
+      return {
+        log: (0, import_callLog.compressCallLog)(e.message ? [...progress.metadata.log, e.message] : progress.metadata.log),
+        ...intermediateResult,
+        errorMessage,
+        timedOut: e instanceof import_errors.TimeoutError
+      };
+    };
+    progress.legacySetErrorHandler(handleError);
+    try {
       let actual;
       let previous;
       const pollIntervals = [0, 100, 250, 500];
-      progress.log(`${metadata.apiName}${callTimeout ? ` with timeout ${callTimeout}ms` : ''}`);
-      if (options.expected) progress.log(`  verifying given screenshot expectation`);else progress.log(`  generating new stable screenshot expectation`);
+      progress.log(`${(0, import_utils.renderTitleForCall)(progress.metadata)}${options.timeout ? ` with timeout ${options.timeout}ms` : ""}`);
+      if (options.expected)
+        progress.log(`  verifying given screenshot expectation`);
+      else
+        progress.log(`  generating new stable screenshot expectation`);
       let isFirstIteration = true;
       while (true) {
-        var _pollIntervals$shift;
-        progress.throwIfAborted();
-        if (this.isClosed()) throw new Error('The page has closed');
-        const screenshotTimeout = (_pollIntervals$shift = pollIntervals.shift()) !== null && _pollIntervals$shift !== void 0 ? _pollIntervals$shift : 1000;
-        if (screenshotTimeout) progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
+        if (this.isClosed())
+          throw new Error("The page has closed");
+        const screenshotTimeout = pollIntervals.shift() ?? 1e3;
+        if (screenshotTimeout)
+          progress.log(`waiting ${screenshotTimeout}ms before taking screenshot`);
         previous = actual;
-        actual = await rafrafScreenshot(progress, screenshotTimeout).catch(e => {
+        actual = await rafrafScreenshot(screenshotTimeout).catch((e) => {
+          if (this.mainFrame().isNonRetriableError(e))
+            throw e;
           progress.log(`failed to take screenshot - ` + e.message);
-          return undefined;
+          return void 0;
         });
-        if (!actual) continue;
-        // Compare against expectation for the first iteration.
+        if (!actual)
+          continue;
         const expectation = options.expected && isFirstIteration ? options.expected : previous;
-        if (areEqualScreenshots(actual, expectation, previous)) break;
-        if (intermediateResult) progress.log(intermediateResult.errorMessage);
+        if (areEqualScreenshots(actual, expectation, previous))
+          break;
+        if (intermediateResult)
+          progress.log(intermediateResult.errorMessage);
         isFirstIteration = false;
       }
-      if (!isFirstIteration) progress.log(`captured a stable screenshot`);
-      if (!options.expected) return {
-        actual
-      };
+      if (!isFirstIteration)
+        progress.log(`captured a stable screenshot`);
+      if (!options.expected)
+        return { actual };
       if (isFirstIteration) {
         progress.log(`screenshot matched expectation`);
         return {};
       }
-      if (areEqualScreenshots(actual, options.expected, undefined)) {
+      if (areEqualScreenshots(actual, options.expected, void 0)) {
         progress.log(`screenshot matched expectation`);
         return {};
       }
       throw new Error(intermediateResult.errorMessage);
-    }, callTimeout).catch(e => {
-      var _intermediateResult;
-      // Q: Why not throw upon isSessionClosedError(e) as in other places?
-      // A: We want user to receive a friendly diff between actual and expected/previous.
-      if (js.isJavaScriptErrorInEvaluate(e) || (0, _selectorParser.isInvalidSelectorError)(e)) throw e;
-      let errorMessage = e.message;
-      if (e instanceof _errors.TimeoutError && (_intermediateResult = intermediateResult) !== null && _intermediateResult !== void 0 && _intermediateResult.previous) errorMessage = `Failed to take two consecutive stable screenshots.`;
-      return {
-        log: (0, _callLog.compressCallLog)(e.message ? [...metadata.log, e.message] : metadata.log),
-        ...intermediateResult,
-        errorMessage,
-        timedOut: e instanceof _errors.TimeoutError
-      };
-    });
+    } catch (e) {
+      return handleError(e);
+    }
   }
-  async screenshot(metadata, options = {}) {
-    const controller = new _progress.ProgressController(metadata, this);
-    return controller.run(progress => this._screenshotter.screenshotPage(progress, options), this._timeoutSettings.timeout(options));
+  async screenshot(progress, options) {
+    return await this.screenshotter.screenshotPage(progress, options);
   }
-  async close(metadata, options = {}) {
-    if (this._closedState === 'closed') return;
-    if (options.reason) this._closeReason = options.reason;
+  async close(options = {}) {
+    if (this._closedState === "closed")
+      return;
+    if (options.reason)
+      this.closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
-    if (this._closedState !== 'closing') {
-      this._closedState = 'closing';
-      // This might throw if the browser context containing the page closes
-      // while we are trying to close the page.
-      await this._delegate.closePage(runBeforeUnload).catch(e => _debugLogger.debugLogger.log('error', e));
+    if (this._closedState !== "closing") {
+      this._closedState = "closing";
+      await this.delegate.closePage(runBeforeUnload).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
-    if (!runBeforeUnload) await this._closedPromise;
-    if (this._ownedContext) await this._ownedContext.close(options);
+    if (!runBeforeUnload)
+      await this._closedPromise;
   }
   isClosed() {
-    return this._closedState === 'closed';
+    return this._closedState === "closed";
   }
   hasCrashed() {
     return this._crashed;
   }
   isClosedOrClosingOrCrashed() {
-    return this._closedState !== 'open' || this._crashed;
+    return this._closedState !== "open" || this._crashed;
   }
-  _addWorker(workerId, worker) {
+  addWorker(workerId, worker) {
     this._workers.set(workerId, worker);
     this.emit(Page.Events.Worker, worker);
   }
-  _removeWorker(workerId) {
+  removeWorker(workerId) {
     const worker = this._workers.get(workerId);
-    if (!worker) return;
+    if (!worker)
+      return;
     worker.didClose();
     this._workers.delete(workerId);
   }
-  _clearWorkers() {
+  clearWorkers() {
     for (const [workerId, worker] of this._workers) {
       worker.didClose();
       this._workers.delete(workerId);
     }
   }
-  async setFileChooserIntercepted(enabled) {
-    this._interceptFileChooser = enabled;
-    await this._delegate.updateFileChooserInterception();
+  async setFileChooserInterceptedBy(enabled, by) {
+    const wasIntercepted = this.fileChooserIntercepted();
+    if (enabled)
+      this._fileChooserInterceptedBy.add(by);
+    else
+      this._fileChooserInterceptedBy.delete(by);
+    if (wasIntercepted !== this.fileChooserIntercepted())
+      await this.delegate.updateFileChooserInterception();
   }
   fileChooserIntercepted() {
-    return this._interceptFileChooser;
+    return this._fileChooserInterceptedBy.size > 0;
   }
   frameNavigatedToNewDocument(frame) {
     this.emit(Page.Events.InternalFrameNavigatedToNewDocument, frame);
     const origin = frame.origin();
-    if (origin) this._browserContext.addVisitedOrigin(origin);
+    if (origin)
+      this.browserContext.addVisitedOrigin(origin);
   }
   allInitScripts() {
-    const bindings = [...this._browserContext._pageBindings.values(), ...this._pageBindings.values()];
-    return [...bindings.map(binding => binding.initScript), ...this._browserContext.initScripts, ...this.initScripts];
+    const bindings = [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()].map((binding) => binding.initScript);
+    if (this.browserContext.bindingsInitScript)
+      bindings.unshift(this.browserContext.bindingsInitScript);
+    return [...bindings, ...this.browserContext.initScripts, ...this.initScripts];
   }
   getBinding(name) {
-    return this._pageBindings.get(name) || this._browserContext._pageBindings.get(name);
+    return this._pageBindings.get(name) || this.browserContext._pageBindings.get(name);
   }
   setScreencastOptions(options) {
-    this._delegate.setScreencastOptions(options).catch(e => _debugLogger.debugLogger.log('error', e));
+    this.delegate.setScreencastOptions(options).catch((e) => import_debugLogger.debugLogger.log("error", e));
     this._frameThrottler.setThrottlingEnabled(!!options);
   }
   throttleScreencastFrameAck(ack) {
-    // Don't ack immediately, tracing has smart throttling logic that is implemented here.
     this._frameThrottler.ack(ack);
   }
   temporarilyDisableTracingScreencastThrottling() {
     this._frameThrottler.recharge();
   }
   async safeNonStallingEvaluateInAllFrames(expression, world, options = {}) {
-    await Promise.all(this.frames().map(async frame => {
+    await Promise.all(this.frames().map(async (frame) => {
       try {
         await frame.nonStallingEvaluateInExistingContext(expression, world);
       } catch (e) {
-        if (options.throwOnJSErrors && js.isJavaScriptErrorInEvaluate(e)) throw e;
+        if (options.throwOnJSErrors && js.isJavaScriptErrorInEvaluate(e))
+          throw e;
       }
     }));
   }
   async hideHighlight() {
-    await Promise.all(this.frames().map(frame => frame.hideHighlight().catch(() => {})));
+    await Promise.all(this.frames().map((frame) => frame.hideHighlight().catch(() => {
+    })));
   }
   markAsServerSideOnly() {
     this._isServerSideOnly = true;
   }
+  async snapshotForAI(progress) {
+    this.lastSnapshotFrameIds = [];
+    const snapshot = await snapshotFrameForAI(progress, this.mainFrame(), 0, this.lastSnapshotFrameIds);
+    return snapshot.join("\n");
+  }
 }
-exports.Page = Page;
-Page.Events = {
-  Close: 'close',
-  Crash: 'crash',
-  Download: 'download',
-  FileChooser: 'filechooser',
-  FrameAttached: 'frameattached',
-  FrameDetached: 'framedetached',
-  InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
-  LocatorHandlerTriggered: 'locatorhandlertriggered',
-  ScreencastFrame: 'screencastframe',
-  Video: 'video',
-  WebSocket: 'websocket',
-  Worker: 'worker'
-};
-class Worker extends _instrumentation.SdkObject {
+class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
-    super(parent, 'worker');
-    this._url = void 0;
-    this._executionContextPromise = void 0;
-    this._executionContextCallback = void 0;
-    this._existingExecutionContext = null;
-    this.openScope = new _utils.LongStandingScope();
-    this._url = url;
-    this._executionContextCallback = () => {};
-    this._executionContextPromise = new Promise(x => this._executionContextCallback = x);
-  }
-  _createExecutionContext(delegate) {
-    this._existingExecutionContext = new js.ExecutionContext(this, delegate, 'worker');
-    this._executionContextCallback(this._existingExecutionContext);
-    return this._existingExecutionContext;
-  }
-  url() {
-    return this._url;
+    super(parent, "worker");
+    this.existingExecutionContext = null;
+    this.openScope = new import_utils.LongStandingScope();
+    this.url = url;
+    this._executionContextCallback = () => {
+    };
+    this._executionContextPromise = new Promise((x) => this._executionContextCallback = x);
+  }
+  static {
+    this.Events = {
+      Close: "close"
+    };
+  }
+  createExecutionContext(delegate) {
+    this.existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
+    this._executionContextCallback(this.existingExecutionContext);
+    return this.existingExecutionContext;
   }
   didClose() {
-    if (this._existingExecutionContext) this._existingExecutionContext.contextDestroyed('Worker was closed');
+    if (this.existingExecutionContext)
+      this.existingExecutionContext.contextDestroyed("Worker was closed");
     this.emit(Worker.Events.Close, this);
-    this.openScope.close(new Error('Worker closed'));
+    this.openScope.close(new Error("Worker closed"));
   }
   async evaluateExpression(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, {
-      returnByValue: true,
-      isFunction
-    }, arg);
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: true, isFunction }, arg);
   }
   async evaluateExpressionHandle(expression, isFunction, arg) {
-    return js.evaluateExpression(await this._executionContextPromise, expression, {
-      returnByValue: false,
-      isFunction
-    }, arg);
+    return js.evaluateExpression(await this._executionContextPromise, expression, { returnByValue: false, isFunction }, arg);
   }
 }
-exports.Worker = Worker;
-Worker.Events = {
-  Close: 'close'
-};
 class PageBinding {
+  static {
+    this.kController = "__playwright__binding__controller__";
+  }
+  static {
+    this.kBindingName = "__playwright__binding__";
+  }
+  static createInitScript() {
+    return new InitScript(`
+      (() => {
+        const module = {};
+        ${rawBindingsControllerSource.source}
+        const property = '${PageBinding.kController}';
+        if (!globalThis[property])
+          globalThis[property] = new (module.exports.BindingsController())(globalThis, '${PageBinding.kBindingName}');
+      })();
+    `);
+  }
   constructor(name, playwrightFunction, needsHandle) {
-    this.name = void 0;
-    this.playwrightFunction = void 0;
-    this.initScript = void 0;
-    this.needsHandle = void 0;
-    this.internal = void 0;
     this.name = name;
     this.playwrightFunction = playwrightFunction;
-    this.initScript = new InitScript(`(${addPageBinding.toString()})(${JSON.stringify(PageBinding.kPlaywrightBinding)}, ${JSON.stringify(name)}, ${needsHandle}, (${_utilityScriptSerializers.source})())`, true /* internal */);
+    this.initScript = new InitScript(`globalThis['${PageBinding.kController}'].addBinding(${JSON.stringify(name)}, ${needsHandle})`);
     this.needsHandle = needsHandle;
-    this.internal = name.startsWith('__pw');
+    this.cleanupScript = `globalThis['${PageBinding.kController}'].removeBinding(${JSON.stringify(name)})`;
   }
   static async dispatch(page, payload, context) {
-    const {
-      name,
-      seq,
-      serializedArgs
-    } = JSON.parse(payload);
+    const { name, seq, serializedArgs } = JSON.parse(payload);
     try {
-      (0, _utils.assert)(context.world);
+      (0, import_utils.assert)(context.world);
       const binding = page.getBinding(name);
-      if (!binding) throw new Error(`Function "${name}" is not exposed`);
+      if (!binding)
+        throw new Error(`Function "${name}" is not exposed`);
       let result;
       if (binding.needsHandle) {
-        const handle = await context.evaluateHandle(takeHandle, {
-          name,
-          seq
-        }).catch(e => null);
-        result = await binding.playwrightFunction({
-          frame: context.frame,
-          page,
-          context: page._browserContext
-        }, handle);
+        const handle = await context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].takeBindingHandle(arg)`, { isFunction: true }, { name, seq }).catch((e) => null);
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, handle);
       } else {
-        if (!Array.isArray(serializedArgs)) throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
-        const args = serializedArgs.map(a => (0, _utilityScriptSerializers.parseEvaluationResultValue)(a));
-        result = await binding.playwrightFunction({
-          frame: context.frame,
-          page,
-          context: page._browserContext
-        }, ...args);
+        if (!Array.isArray(serializedArgs))
+          throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
+        const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
+        result = await binding.playwrightFunction({ frame: context.frame, page, context: page.browserContext }, ...args);
       }
-      context.evaluate(deliverResult, {
-        name,
-        seq,
-        result
-      }).catch(e => _debugLogger.debugLogger.log('error', e));
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     } catch (error) {
-      context.evaluate(deliverResult, {
-        name,
-        seq,
-        error
-      }).catch(e => _debugLogger.debugLogger.log('error', e));
-    }
-    function takeHandle(arg) {
-      const handle = globalThis[arg.name]['handles'].get(arg.seq);
-      globalThis[arg.name]['handles'].delete(arg.seq);
-      return handle;
-    }
-    function deliverResult(arg) {
-      const callbacks = globalThis[arg.name]['callbacks'];
-      if ('error' in arg) callbacks.get(arg.seq).reject(arg.error);else callbacks.get(arg.seq).resolve(arg.result);
-      callbacks.delete(arg.seq);
+      context.evaluateExpressionHandle(`arg => globalThis['${PageBinding.kController}'].deliverBindingResult(arg)`, { isFunction: true }, { name, seq, error }).catch((e) => import_debugLogger.debugLogger.log("error", e));
     }
   }
 }
-exports.PageBinding = PageBinding;
-PageBinding.kPlaywrightBinding = '__playwright__binding__';
-function addPageBinding(playwrightBinding, bindingName, needsHandle, utilityScriptSerializers) {
-  const binding = globalThis[playwrightBinding];
-  globalThis[bindingName] = (...args) => {
-    const me = globalThis[bindingName];
-    if (needsHandle && args.slice(1).some(arg => arg !== undefined)) throw new Error(`exposeBindingHandle supports a single argument, ${args.length} received`);
-    let callbacks = me['callbacks'];
-    if (!callbacks) {
-      callbacks = new Map();
-      me['callbacks'] = callbacks;
-    }
-    const seq = (me['lastSeq'] || 0) + 1;
-    me['lastSeq'] = seq;
-    let handles = me['handles'];
-    if (!handles) {
-      handles = new Map();
-      me['handles'] = handles;
-    }
-    const promise = new Promise((resolve, reject) => callbacks.set(seq, {
-      resolve,
-      reject
-    }));
-    let payload;
-    if (needsHandle) {
-      handles.set(seq, args[0]);
-      payload = {
-        name: bindingName,
-        seq
-      };
-    } else {
-      const serializedArgs = [];
-      for (let i = 0; i < args.length; i++) {
-        serializedArgs[i] = utilityScriptSerializers.serializeAsCallArgument(args[i], v => {
-          return {
-            fallThrough: v
-          };
-        });
-      }
-      payload = {
-        name: bindingName,
-        seq,
-        serializedArgs
-      };
-    }
-    binding(JSON.stringify(payload));
-    return promise;
-  };
-  globalThis[bindingName].__installed = true;
-}
 class InitScript {
-  constructor(source, internal, name) {
-    this.source = void 0;
-    this.internal = void 0;
-    this.name = void 0;
-    const guid = (0, _crypto.createGuid)();
+  constructor(source) {
     this.source = `(() => {
-      globalThis.__pwInitScripts = globalThis.__pwInitScripts || {};
-      const hasInitScript = globalThis.__pwInitScripts[${JSON.stringify(guid)}];
-      if (hasInitScript)
-        return;
-      globalThis.__pwInitScripts[${JSON.stringify(guid)}] = true;
       ${source}
     })();`;
-    this.internal = !!internal;
-    this.name = name;
   }
 }
-exports.InitScript = InitScript;
 class FrameThrottler {
   constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
     this._acks = [];
-    this._defaultInterval = void 0;
-    this._throttlingInterval = void 0;
-    this._nonThrottledFrames = void 0;
-    this._budget = void 0;
     this._throttlingEnabled = false;
-    this._timeoutId = void 0;
     this._nonThrottledFrames = nonThrottledFrames;
     this._budget = nonThrottledFrames;
     this._defaultInterval = defaultInterval;
@@ -827,15 +744,15 @@ class FrameThrottler {
   dispose() {
     if (this._timeoutId) {
       clearTimeout(this._timeoutId);
-      this._timeoutId = undefined;
+      this._timeoutId = void 0;
     }
   }
   setThrottlingEnabled(enabled) {
     this._throttlingEnabled = enabled;
   }
   recharge() {
-    // Send all acks, reset budget.
-    for (const ack of this._acks) ack();
+    for (const ack of this._acks)
+      ack();
     this._acks = [];
     this._budget = this._nonThrottledFrames;
     if (this._timeoutId) {
@@ -845,7 +762,6 @@ class FrameThrottler {
   }
   ack(ack) {
     if (!this._timeoutId) {
-      // Already disposed.
       ack();
       return;
     }
@@ -858,11 +774,64 @@ class FrameThrottler {
       ack();
     }
     if (this._throttlingEnabled && this._budget <= 0) {
-      // Non-throttled frame budget is exceeded. Next ack will be throttled.
       this._timeoutId = setTimeout(() => this._tick(), this._throttlingInterval);
     } else {
-      // Either not throttling, or still under budget. Next ack will be after the default timeout.
       this._timeoutId = setTimeout(() => this._tick(), this._defaultInterval);
     }
   }
-}
+}
+async function snapshotFrameForAI(progress, frame, frameOrdinal, frameIds) {
+  const snapshot = await frame.retryWithProgressAndTimeouts(progress, [1e3, 2e3, 4e3, 8e3], async (continuePolling) => {
+    try {
+      const context = await progress.race(frame._utilityContext());
+      const injectedScript = await progress.race(context.injectedScript());
+      const snapshotOrRetry = await progress.race(injectedScript.evaluate((injected, refPrefix) => {
+        const node = injected.document.body;
+        if (!node)
+          return true;
+        return injected.ariaSnapshot(node, { forAI: true, refPrefix });
+      }, frameOrdinal ? "f" + frameOrdinal : ""));
+      if (snapshotOrRetry === true)
+        return continuePolling;
+      return snapshotOrRetry;
+    } catch (e) {
+      if (frame.isNonRetriableError(e))
+        throw e;
+      return continuePolling;
+    }
+  });
+  const lines = snapshot.split("\n");
+  const result = [];
+  for (const line of lines) {
+    const match = line.match(/^(\s*)- iframe (?:\[active\] )?\[ref=(.*)\]/);
+    if (!match) {
+      result.push(line);
+      continue;
+    }
+    const leadingSpace = match[1];
+    const ref = match[2];
+    const frameSelector = `aria-ref=${ref} >> internal:control=enter-frame`;
+    const frameBodySelector = `${frameSelector} >> body`;
+    const child = await progress.race(frame.selectors.resolveFrameForSelector(frameBodySelector, { strict: true }));
+    if (!child) {
+      result.push(line);
+      continue;
+    }
+    const frameOrdinal2 = frameIds.length + 1;
+    frameIds.push(child.frame._id);
+    try {
+      const childSnapshot = await snapshotFrameForAI(progress, child.frame, frameOrdinal2, frameIds);
+      result.push(line + ":", ...childSnapshot.map((l) => leadingSpace + "  " + l));
+    } catch {
+      result.push(line);
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InitScript,
+  Page,
+  PageBinding,
+  Worker
+});