patchright-core 1.52.4 → 1.55.0

package/lib/server/page.js

@@ -31,10 +31,10 @@ __export(page_exports, {
   InitScript: () => InitScript,
   Page: () => Page,
   PageBinding: () => PageBinding,
-  Worker: () => Worker,
-  kBuiltinsScript: () => kBuiltinsScript
+  Worker: () => Worker
 });
 module.exports = __toCommonJS(page_exports);
+var import_pageBinding = require("./pageBinding");
 var accessibility = __toESM(require("./accessibility"));
 var import_browserContext = require("./browserContext");
 var import_console = require("./console");
@@ -44,19 +44,15 @@ var frames = __toESM(require("./frames"));
 var import_helper = require("./helper");
 var input = __toESM(require("./input"));
 var import_instrumentation = require("./instrumentation");
-var import_builtins = require("../utils/isomorphic/builtins");
-var import_pageBinding = require("./pageBinding");
 var js = __toESM(require("./javascript"));
-var import_progress = require("./progress");
 var import_screenshotter = require("./screenshotter");
-var import_timeoutSettings = require("./timeoutSettings");
 var import_utils = require("../utils");
-var import_crypto = require("./utils/crypto");
 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");
 class Page extends import_instrumentation.SdkObject {
   constructor(delegate, browserContext) {
@@ -68,37 +64,39 @@ class Page extends import_instrumentation.SdkObject {
     this._crashed = false;
     this.openScope = new import_utils.LongStandingScope();
     this._emulatedMedia = {};
-    this._interceptFileChooser = false;
+    this._fileChooserInterceptedBy = /* @__PURE__ */ new Set();
     this._pageBindings = /* @__PURE__ */ new Map();
     this.initScripts = [];
     this._workers = /* @__PURE__ */ new Map();
-    this._video = null;
-    this._isServerSideOnly = false;
+    this.requestInterceptors = [];
+    this.video = null;
     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.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 import_timeoutSettings.TimeoutSettings(browserContext._timeoutSettings);
-    this._screenshotter = new import_screenshotter.Screenshotter(this);
-    this._frameManager = new frames.FrameManager(this);
+    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;
+    this.isStorageStatePage = browserContext.isCreatingStorageStatePage();
   }
   static {
     this.Events = {
       Close: "close",
       Crash: "crash",
       Download: "download",
+      EmulatedSizeChanged: "emulatedsizechanged",
       FileChooser: "filechooser",
       FrameAttached: "frameattached",
       FrameDetached: "framedetached",
@@ -120,14 +118,14 @@ class Page extends import_instrumentation.SdkObject {
   }
   _markInitialized(error = void 0, contextEvent = import_browserContext.BrowserContext.Events.Page) {
     if (error) {
-      if (this._browserContext.isClosingOrClosed())
+      if (this.browserContext.isClosingOrClosed())
         return;
-      this._frameManager.createDummyMainFrameIfNeeded();
+      this.frameManager.createDummyMainFrameIfNeeded();
     }
     this._initialized = error || this;
     this.emitOnContext(contextEvent, this);
     for (const { event, args } of this._eventsToEmitAfterInitialized)
-      this._browserContext.emit(event, ...args);
+      this.browserContext.emit(event, ...args);
     this._eventsToEmitAfterInitialized = [];
     if (this.isClosed())
       this.emit(Page.Events.Close);
@@ -142,41 +140,32 @@ class Page extends import_instrumentation.SdkObject {
     return this._initializedPromise;
   }
   emitOnContext(event, ...args) {
-    if (this._isServerSideOnly)
+    if (this.isStorageStatePage)
       return;
-    this._browserContext.emit(event, ...args);
+    this.browserContext.emit(event, ...args);
   }
   emitOnContextOnceInitialized(event, ...args) {
-    if (this._isServerSideOnly)
+    if (this.isStorageStatePage)
       return;
     if (this._initialized)
-      this._browserContext.emit(event, ...args);
+      this.browserContext.emit(event, ...args);
     else
       this._eventsToEmitAfterInitialized.push({ event, args });
   }
-  async resetForReuse(metadata) {
-    this.setDefaultNavigationTimeout(void 0);
-    this.setDefaultTimeout(void 0);
-    this._locatorHandlers.clear();
-    await this._removeExposedBindings();
-    await this._removeInitScripts();
-    await this.setClientRequestInterceptor(void 0);
-    await this._setServerRequestInterceptor(void 0);
-    await this.setFileChooserIntercepted(false);
-    await this.mainFrame().goto(metadata, "about:blank");
+  async resetForReuse(progress) {
+    await this.mainFrame().gotoImpl(progress, "about:blank", {});
     this._emulatedSize = void 0;
     this._emulatedMedia = {};
     this._extraHTTPHeaders = void 0;
-    this._interceptFileChooser = false;
     await Promise.all([
-      this._delegate.updateEmulatedViewportSize(),
-      this._delegate.updateEmulateMedia(),
-      this._delegate.updateFileChooserInterception()
+      this.delegate.updateEmulatedViewportSize(),
+      this.delegate.updateEmulateMedia(),
+      this.delegate.updateExtraHTTPHeaders()
     ]);
-    await this._delegate.resetForReuse();
+    await this.delegate.resetForReuse(progress);
   }
   _didClose() {
-    this._frameManager.dispose();
+    this.frameManager.dispose();
     this._frameThrottler.dispose();
     (0, import_utils.assert)(this._closedState !== "closed", "Page closed twice");
     this._closedState = "closed";
@@ -186,7 +175,7 @@ class Page extends import_instrumentation.SdkObject {
     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;
@@ -207,108 +196,110 @@ class Page extends import_instrumentation.SdkObject {
     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);
+    return this.frameManager.frames();
   }
-  setDefaultTimeout(timeout) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-  async exposeBinding(name, needsHandle, playwrightBinding) {
+  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))
+    if (this.browserContext._pageBindings.has(name))
       throw new Error(`Function "${name}" has been already registered in the browser context`);
     const binding = new PageBinding(name, playwrightBinding, needsHandle);
     this._pageBindings.set(name, binding);
-    await this._delegate.exposeBinding(binding);
+    await this.delegate.exposeBinding(binding);
   }
-  async _removeExposedBindings() {
+  async removeExposedBindings(bindings) {
     for (const key of this._pageBindings.keys()) {
       if (!key.startsWith("__pw"))
         this._pageBindings.delete(key);
     }
-    await this._delegate.removeExposedBindings();
+    await this.delegate.removeExposedBindings();
   }
-  setExtraHTTPHeaders(headers) {
-    this._extraHTTPHeaders = headers;
-    return this._delegate.updateExtraHTTPHeaders();
+  async setExtraHTTPHeaders(progress, headers) {
+    const oldHeaders = this._extraHTTPHeaders;
+    try {
+      this._extraHTTPHeaders = headers;
+      await progress.race(this.delegate.updateExtraHTTPHeaders());
+    } catch (error) {
+      this._extraHTTPHeaders = oldHeaders;
+      this.delegate.updateExtraHTTPHeaders().catch(() => {
+      });
+      throw error;
+    }
   }
   extraHTTPHeaders() {
     return this._extraHTTPHeaders;
   }
-  async _onBindingCalled(payload, context) {
+  async onBindingCalled(payload, context) {
     if (this._closedState === "closed")
       return;
     await PageBinding.dispatch(this, payload, context);
   }
-  _addConsoleMessage(type, args, location, text) {
+  addConsoleMessage(type, args, location, text) {
     const message = new import_console.ConsoleMessage(this, type, text, args, location);
-    const intercepted = this._frameManager.interceptConsoleMessage(message);
+    const intercepted = this.frameManager.interceptConsoleMessage(message);
     if (intercepted) {
       args.forEach((arg) => arg.dispose());
       return;
     }
     this.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.Console, message);
   }
-  async reload(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+  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, options),
-        this._delegate.reload()
+        progress.race(this.delegate.reload())
       ]);
       return response;
-    }), this._timeoutSettings.navigationTimeout(options));
+    });
   }
-  async goBack(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+  async goBack(progress, options) {
+    return this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this._delegate.goBack();
-      if (!result)
+      const result = await progress.race(this.delegate.goBack());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
         return null;
+      }
       const response = await waitPromise;
       if (error)
         throw error;
       return response;
-    }), this._timeoutSettings.navigationTimeout(options));
+    });
   }
-  async goForward(metadata, options) {
-    const controller = new import_progress.ProgressController(metadata, this);
-    return controller.run((progress) => this.mainFrame().raceNavigationAction(progress, options, async () => {
+  async goForward(progress, options) {
+    return this.mainFrame().raceNavigationAction(progress, async () => {
       let error;
       const waitPromise = this.mainFrame()._waitForNavigation(progress, false, options).catch((e) => {
         error = e;
         return null;
       });
-      const result = await this._delegate.goForward();
-      if (!result)
+      const result = await progress.race(this.delegate.goForward());
+      if (!result) {
+        waitPromise.catch(() => {
+        });
         return null;
+      }
       const response = await waitPromise;
       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;
@@ -329,15 +320,11 @@ class Page extends import_instrumentation.SdkObject {
   }
   async performActionPreChecks(progress) {
     await this._performWaitForNavigationCheck(progress);
-    progress.throwIfAborted();
     await this._performLocatorHandlersCheckpoint(progress);
-    progress.throwIfAborted();
     await this._performWaitForNavigationCheck(progress);
   }
   async _performWaitForNavigationCheck(progress) {
-    if (process.env.PLAYWRIGHT_SKIP_NAVIGATION_CHECK)
-      return;
-    const mainFrame = this._frameManager.mainFrame();
+    const mainFrame = this.frameManager.mainFrame();
     if (!mainFrame || !mainFrame.pendingDocument())
       return;
     const url = mainFrame.pendingDocument()?.request?.url();
@@ -356,30 +343,29 @@ class Page extends import_instrumentation.SdkObject {
       return;
     for (const [uid, handler] of this._locatorHandlers) {
       if (!handler.resolved) {
-        if (await this.mainFrame().isVisibleInternal(handler.selector, { strict: true })) {
+        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, import_utils2.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, import_utils2.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);
-        progress.throwIfAborted();
+        await progress.race(this.openScope.race(promise)).finally(() => --this._locatorHandlerRunningCounter);
         progress.log(`  interception handler has finished, continuing`);
       }
     }
   }
-  async emulateMedia(options) {
+  async emulateMedia(progress, options) {
+    const oldEmulatedMedia = { ...this._emulatedMedia };
     if (options.media !== void 0)
       this._emulatedMedia.media = options.media;
     if (options.colorScheme !== void 0)
@@ -390,10 +376,17 @@ class Page extends import_instrumentation.SdkObject {
       this._emulatedMedia.forcedColors = options.forcedColors;
     if (options.contrast !== void 0)
       this._emulatedMedia.contrast = options.contrast;
-    await this._delegate.updateEmulateMedia();
+    try {
+      await progress.race(this.delegate.updateEmulateMedia());
+    } catch (error) {
+      this._emulatedMedia = oldEmulatedMedia;
+      this.delegate.updateEmulateMedia().catch(() => {
+      });
+      throw error;
+    }
   }
   emulatedMedia() {
-    const contextOptions = this._browserContext._options;
+    const contextOptions = this.browserContext._options;
     return {
       media: this._emulatedMedia.media || "no-override",
       colorScheme: this._emulatedMedia.colorScheme !== void 0 ? this._emulatedMedia.colorScheme : contextOptions.colorScheme ?? "light",
@@ -402,53 +395,78 @@ class Page extends import_instrumentation.SdkObject {
       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;
+    try {
+      this._setEmulatedSize({ viewport: { ...viewportSize }, screen: { ...viewportSize } });
+      await progress.race(this.delegate.updateEmulatedViewportSize());
+    } catch (error) {
+      this._emulatedSize = oldEmulatedSize;
+      this.delegate.updateEmulatedViewportSize().catch(() => {
+      });
+      throw error;
+    }
+  }
+  setEmulatedSizeFromWindowOpen(emulatedSize) {
+    this._setEmulatedSize(emulatedSize);
   }
-  viewportSize() {
-    return 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;
+    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, name);
+  async addInitScript(progress, source) {
+    const initScript = new InitScript(source);
     this.initScripts.push(initScript);
-    await this._delegate.addInitScript(initScript);
+    try {
+      await progress.race(this.delegate.addInitScript(initScript));
+    } catch (error) {
+      this.removeInitScripts([initScript]).catch(() => {
+      });
+      throw error;
+    }
+    return initScript;
   }
-  async _removeInitScripts() {
+  async removeInitScripts(initScripts) {
     this.initScripts.splice(0, this.initScripts.length);
-    await this._delegate.removeInitScripts();
+    await this.delegate.removeInitScripts();
   }
   needsRequestInterception() {
-    return !!this._clientRequestInterceptor || !!this._serverRequestInterceptor || !!this._browserContext._requestInterceptor;
+    return this.requestInterceptors.length > 0 || this.browserContext.requestInterceptors.length > 0;
   }
-  async setClientRequestInterceptor(handler) {
-    this._clientRequestInterceptor = handler;
-    await this._delegate.updateRequestInterception();
+  async addRequestInterceptor(progress, handler, prepend) {
+    if (prepend)
+      this.requestInterceptors.unshift(handler);
+    else
+      this.requestInterceptors.push(handler);
+    await this.delegate.updateRequestInterception();
   }
-  async _setServerRequestInterceptor(handler) {
-    this._serverRequestInterceptor = 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 || {});
+      await this.mainFrame().rafrafTimeout(progress, timeout);
+      return await this.screenshotter.screenshotPage(progress, options || {});
     };
     const comparator = (0, import_comparators.getComparator)("image/png");
-    const controller = new import_progress.ProgressController(metadata, this);
     if (!options.expected && options.isNot)
       return { errorMessage: '"not" matcher requires expected result' };
     try {
@@ -458,7 +476,7 @@ class Page extends import_instrumentation.SdkObject {
     } catch (error) {
       return { errorMessage: error.message };
     }
-    let intermediateResult = void 0;
+    let intermediateResult;
     const areEqualScreenshots = (actual, expected, previous) => {
       const comparatorResult = actual && expected ? comparator(actual, expected, options) : void 0;
       if (comparatorResult !== void 0 && !!comparatorResult === !!options.isNot)
@@ -467,26 +485,26 @@ class Page extends import_instrumentation.SdkObject {
         intermediateResult = { errorMessage: comparatorResult.errorMessage, diff: comparatorResult.diff, actual, previous };
       return false;
     };
-    const callTimeout = this._timeoutSettings.timeout(options);
-    return controller.run(async (progress) => {
+    try {
       let actual;
       let previous;
       const pollIntervals = [0, 100, 250, 500];
-      progress.log(`${metadata.apiName}${callTimeout ? ` with timeout ${callTimeout}ms` : ""}`);
+      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) {
-        progress.throwIfAborted();
         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 void 0;
         });
@@ -512,41 +530,35 @@ class Page extends import_instrumentation.SdkObject {
         return {};
       }
       throw new Error(intermediateResult.errorMessage);
-    }, callTimeout).catch((e) => {
+    } catch (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 ? [...metadata.log, e.message] : metadata.log),
+        log: (0, import_callLog.compressCallLog)(e.message ? [...progress.metadata.log, e.message] : progress.metadata.log),
         ...intermediateResult,
         errorMessage,
         timedOut: e instanceof import_errors.TimeoutError
       };
-    });
+    }
   }
-  async screenshot(metadata, options = {}) {
-    const controller = new import_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 = {}) {
+  async close(options = {}) {
     if (this._closedState === "closed")
       return;
     if (options.reason)
-      this._closeReason = options.reason;
+      this.closeReason = options.reason;
     const runBeforeUnload = !!options.runBeforeUnload;
     if (this._closedState !== "closing") {
       this._closedState = "closing";
-      await this._delegate.closePage(runBeforeUnload).catch((e) => import_debugLogger.debugLogger.log("error", e));
+      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);
   }
   isClosed() {
     return this._closedState === "closed";
@@ -557,41 +569,46 @@ class Page extends import_instrumentation.SdkObject {
   isClosedOrClosingOrCrashed() {
     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;
     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);
+      this.browserContext.addVisitedOrigin(origin);
   }
   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) => import_debugLogger.debugLogger.log("error", e));
+    this.delegate.setScreencastOptions(options).catch((e) => import_debugLogger.debugLogger.log("error", e));
     this._frameThrottler.setThrottlingEnabled(!!options);
   }
   throttleScreencastFrameAck(ack) {
@@ -614,19 +631,21 @@ class Page extends import_instrumentation.SdkObject {
     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");
   }
   allBindings() {
-    return [...this._browserContext._pageBindings.values(), ...this._pageBindings.values()];
+    return [...this.browserContext._pageBindings.values(), ...this._pageBindings.values()];
   }
 }
 class Worker extends import_instrumentation.SdkObject {
   constructor(parent, url) {
     super(parent, "worker");
-    this._existingExecutionContext = null;
+    this.existingExecutionContext = null;
     this.openScope = new import_utils.LongStandingScope();
-    this._url = url;
+    this.url = url;
     this._executionContextCallback = () => {
     };
     this._executionContextPromise = new Promise((x) => this._executionContextCallback = x);
@@ -636,17 +655,14 @@ class Worker extends import_instrumentation.SdkObject {
       Close: "close"
     };
   }
-  _createExecutionContext(delegate) {
-    this._existingExecutionContext = new js.ExecutionContext(this, delegate, "worker");
-    this._executionContextCallback(this._existingExecutionContext);
-    return this._existingExecutionContext;
-  }
-  url() {
-    return this._url;
+  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"));
   }
@@ -663,7 +679,7 @@ class Worker extends import_instrumentation.SdkObject {
   }
   async evaluateExpressionHandle(expression, isFunction, arg, isolatedContext) {
     let context = await this._executionContextPromise;
-    if (this._context.constructor.name === "FrameExecutionContext") {
+    if (context.constructor.name === "FrameExecutionContext") {
       const frame = this._context.frame;
       if (frame) {
         if (isolatedContext) context = await frame._utilityContext();
@@ -694,7 +710,7 @@ class PageBinding {
       } 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) => js.parseEvaluationResultValue(a));
+        const args = serializedArgs.map((a) => (0, import_utilityScriptSerializers.parseEvaluationResultValue)(a));
         result = await binding.playwrightFunction({ frame: context.frame, page, context: page._browserContext }, ...args);
       }
       context.evaluate(import_pageBinding.deliverBindingResult, { name, seq, result }).catch((e) => import_debugLogger.debugLogger.log("error", e));
@@ -704,18 +720,10 @@ class PageBinding {
   }
 }
 class InitScript {
-  constructor(source, internal, name) {
-    const guid = (0, import_crypto.createGuid)();
+  constructor(source) {
     this.source = `(() => { ${source} })();`;
-    this.internal = !!internal;
-    this.name = name;
   }
 }
-const kBuiltinsScript = new InitScript(
-  `(${import_builtins.builtins})()`,
-  true
-  /* internal */
-);
 class FrameThrottler {
   constructor(nonThrottledFrames, defaultInterval, throttlingInterval) {
     this._acks = [];
@@ -765,11 +773,58 @@ class FrameThrottler {
     }
   }
 }
+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, { mode: "ai", 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,
-  kBuiltinsScript
+  Worker
 });