patchright-core 1.52.4 → 1.55.0

package/lib/server/chromium/crPage.js

@@ -43,7 +43,6 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
-var import_page2 = require("../page");
 var import_registry = require("../registry");
 var import_crAccessibility = require("./crAccessibility");
 var import_crBrowser = require("./crBrowser");
@@ -59,7 +58,6 @@ var import_videoRecorder = require("./videoRecorder");
 var import_browserContext = require("../browserContext");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
-const UTILITY_WORLD_NAME = "__playwright_utility_world__";
 class CRPage {
   constructor(client, targetId, browserContext, opener, bits) {
     this._sessions = /* @__PURE__ */ new Map();
@@ -79,7 +77,8 @@ class CRPage {
     this._pdf = new import_crPdf.CRPDF(client);
     this._coverage = new import_crCoverage.CRCoverage(client);
     this._browserContext = browserContext;
-    this._page = new import_page2.Page(this, browserContext);
+    this._page = new import_page.Page(this, browserContext);
+    this.utilityWorldName = `__playwright_utility_world_${this._page.guid}`;
     this._networkManager = new import_crNetworkManager.CRNetworkManager(this._page, null);
     this.updateOffline();
     this.updateExtraHTTPHeaders();
@@ -92,7 +91,7 @@ class CRPage {
       const features = opener._nextWindowOpenPopupFeatures.shift() || [];
       const viewportSize = import_helper.helper.getViewportSizeFromWindowFeatures(features);
       if (viewportSize)
-        this._page._emulatedSize = { viewport: viewportSize, screen: viewportSize };
+        this._page.setEmulatedSizeFromWindowOpen({ viewport: viewportSize, screen: viewportSize });
     }
     const createdEvent = this._isBackgroundPage ? import_crBrowser.CRBrowserContext.CREvents.BackgroundPage : import_browserContext.BrowserContext.Events.Page;
     this._mainFrameSession._initialize(bits.hasUIWindow).then(
@@ -101,7 +100,7 @@ class CRPage {
     );
   }
   static mainFrameSession(page) {
-    const crPage = page._delegate;
+    const crPage = page.delegate;
     return crPage._mainFrameSession;
   }
   async _forAllFrameSessions(cb) {
@@ -198,8 +197,11 @@ class CRPage {
     this._page.initScripts.push(initScript);
     await this._forAllFrameSessions((frame) => frame._evaluateOnNewDocument(initScript, world));
   }
-  async removeInitScripts() {
-    await this._forAllFrameSessions((frame) => frame._removeEvaluatesOnNewDocument());
+  async exposePlaywrightBinding() {
+    await this._forAllFrameSessions((frame) => frame.exposePlaywrightBinding());
+  }
+  async removeInitScripts(initScripts) {
+    await this._forAllFrameSessions((frame) => frame._removeEvaluatesOnNewDocument(initScripts));
   }
   async closePage(runBeforeUnload) {
     if (runBeforeUnload)
@@ -211,7 +213,7 @@ class CRPage {
     await this._mainFrameSession._client.send("Emulation.setDefaultBackgroundColorOverride", { color });
   }
   async takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, scale) {
-    const { visualViewport } = await this._mainFrameSession._client.send("Page.getLayoutMetrics");
+    const { visualViewport } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
     if (!documentRect) {
       documentRect = {
         x: visualViewport.pageX + viewportRect.x,
@@ -227,8 +229,7 @@ class CRPage {
       const deviceScaleFactor = this._browserContext._options.deviceScaleFactor || 1;
       clip.scale /= deviceScaleFactor;
     }
-    progress.throwIfAborted();
-    const result = await this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport });
+    const result = await progress.race(this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport }));
     return Buffer.from(result.data, "base64");
   }
   async getContentFrame(handle) {
@@ -281,8 +282,8 @@ class CRPage {
     await this._mainFrameSession._client.send("Page.enable").catch((e) => {
     });
   }
-  async resetForReuse() {
-    await this.rawMouse.move(-1, -1, "none", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), true);
+  async resetForReuse(progress) {
+    await this.rawMouse.move(progress, -1, -1, "none", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), true);
   }
   async pdf(options) {
     return this._pdf.generate(options);
@@ -332,8 +333,8 @@ class FrameSession {
     this._videoRecorder = null;
     this._screencastId = null;
     this._screencastClients = /* @__PURE__ */ new Set();
-    this._evaluateOnNewDocumentIdentifiers = [];
     this._workerSessions = /* @__PURE__ */ new Map();
+    this._initScriptIds = /* @__PURE__ */ new Map();
     this._exposedBindingNames = [];
     this._evaluateOnNewDocumentScripts = [];
     this._parsedExecutionContextIds = [];
@@ -383,13 +384,12 @@ class FrameSession {
     ]);
   }
   async _initialize(hasUIWindow) {
-    const isSettingStorageState = this._page._browserContext.isSettingStorageState();
-    if (!isSettingStorageState && hasUIWindow && !this._crPage._browserContext._browser.isClank() && !this._crPage._browserContext._options.noDefaultViewport) {
+    if (!this._page.isStorageStatePage && hasUIWindow && !this._crPage._browserContext._browser.isClank() && !this._crPage._browserContext._options.noDefaultViewport) {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
     let screencastOptions;
-    if (!isSettingStorageState && this._isMainFrame() && this._crPage._browserContext._options.recordVideo && hasUIWindow) {
+    if (!this._page.isStorageStatePage && this._isMainFrame() && this._crPage._browserContext._options.recordVideo && hasUIWindow) {
       const screencastId = (0, import_crypto2.createGuid)();
       const outputFile = import_path.default.join(this._crPage._browserContext._options.recordVideo.dir, screencastId + ".webm");
       screencastOptions = {
@@ -423,9 +423,9 @@ class FrameSession {
             this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.lifecycleEvent", (event) => this._onLifecycleEvent(event)));
           });
         } else {
-          const localFrames = this._isMainFrame() ? this._page.frames() : [this._page._frameManager.frame(this._targetId)];
+          const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)];
           for (const frame of localFrames) {
-            this._page._frameManager.frame(frame._id)._context("utility");
+            this._page.frameManager.frame(frame._id)._context("utility");
             for (const binding of this._crPage._browserContext._pageBindings.values())
               frame.evaluateExpression(binding.source).catch((e) => {
               });
@@ -441,12 +441,23 @@ class FrameSession {
       lifecycleEventsEnabled = this._client.send("Page.setLifecycleEventsEnabled", { enabled: true }),
       this._client.send("Page.addScriptToEvaluateOnNewDocument", {
         source: "",
-        worldName: UTILITY_WORLD_NAME
+        worldName: this._crPage.utilityWorldName
       }),
       this._crPage._networkManager.addSession(this._client, void 0, this._isMainFrame()),
-      this._client.send("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true })
+      this._client.send("Target.setAutoAttach", {
+        autoAttach: true,
+        waitForDebuggerOnStart: true,
+        flatten: true,
+        filter: [
+          { type: "iframe" },
+          { type: "worker" },
+          { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
+        ]
+      })
     ];
-    if (!isSettingStorageState) {
+    if (!this._page.isStorageStatePage) {
+      if (this._crPage._browserContext.needsPlaywrightBinding())
+        promises.push(this.exposePlaywrightBinding());
       if (this._isMainFrame())
         promises.push(this._client.send("Emulation.setFocusEmulationEnabled", { enabled: true }));
       const options = this._crPage._browserContext._options;
@@ -477,10 +488,12 @@ class FrameSession {
       if (screencastOptions)
         promises.push(this._startVideoRecording(screencastOptions));
     }
-    if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size)) promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
+    if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size))
+      promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
-    if (this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size) await this._client.send("Runtime.runIfWaitingForDebugger");
+    if (this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size)
+      await this._client.send("Runtime.runIfWaitingForDebugger");
   }
   dispose() {
     this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
@@ -495,7 +508,8 @@ class FrameSession {
   }
   async _navigate(frame, url, referrer) {
     const response = await this._client.send("Page.navigate", { url, referrer, frameId: frame._id, referrerPolicy: "unsafeUrl" });
-    this._client._sendMayFail("Page.waitForDebugger");
+    if (response.isDownload)
+      throw new frames.NavigationAbortedError(response.loaderId, "Download is starting");
     if (response.errorText)
       throw new frames.NavigationAbortedError(response.loaderId, `${response.errorText} at ${url}`);
     return { newDocumentId: response.loaderId };
@@ -504,9 +518,9 @@ class FrameSession {
     if (this._eventBelongsToStaleFrame(event.frameId))
       return;
     if (event.name === "load")
-      this._page._frameManager.frameLifecycleEvent(event.frameId, "load");
+      this._page.frameManager.frameLifecycleEvent(event.frameId, "load");
     else if (event.name === "DOMContentLoaded")
-      this._page._frameManager.frameLifecycleEvent(event.frameId, "domcontentloaded");
+      this._page.frameManager.frameLifecycleEvent(event.frameId, "domcontentloaded");
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
     var document = await this._client._sendMayFail("DOM.getDocument");
     if (!document) return;
@@ -518,7 +532,7 @@ class FrameSession {
     for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId });
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
     try {
-      await this._page._frameManager.frame(this._targetId)._context("utility");
+      await this._page.frameManager.frame(this._targetId)._context("utility");
     } catch {
     }
     ;
@@ -532,7 +546,7 @@ class FrameSession {
       this._handleFrameTree(child);
   }
   _eventBelongsToStaleFrame(frameId) {
-    const frame = this._page._frameManager.frame(frameId);
+    const frame = this._page.frameManager.frame(frameId);
     if (!frame)
       return true;
     const session = this._crPage._sessionForFrame(frame);
@@ -542,20 +556,20 @@ class FrameSession {
     const frameSession = this._crPage._sessions.get(frameId);
     if (frameSession && frameId !== this._targetId) {
       frameSession._swappedIn = true;
-      const frame = this._page._frameManager.frame(frameId);
+      const frame = this._page.frameManager.frame(frameId);
       if (frame)
-        this._page._frameManager.removeChildFramesRecursively(frame);
+        this._page.frameManager.removeChildFramesRecursively(frame);
       return;
     }
-    if (parentFrameId && !this._page._frameManager.frame(parentFrameId)) {
+    if (parentFrameId && !this._page.frameManager.frame(parentFrameId)) {
       return;
     }
-    this._page._frameManager.frameAttached(frameId, parentFrameId);
+    this._page.frameManager.frameAttached(frameId, parentFrameId);
   }
   async _onFrameNavigated(framePayload, initial) {
     if (this._eventBelongsToStaleFrame(framePayload.id))
       return;
-    this._page._frameManager.frameCommittedNewDocumentNavigation(framePayload.id, framePayload.url + (framePayload.urlFragment || ""), framePayload.name || "", framePayload.loaderId, initial);
+    this._page.frameManager.frameCommittedNewDocumentNavigation(framePayload.id, framePayload.url + (framePayload.urlFragment || ""), framePayload.name || "", framePayload.loaderId, initial);
     if (!initial)
       this._firstNonInitialNavigationCommittedFulfill();
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
@@ -569,7 +583,7 @@ class FrameSession {
     for (const nodeId of query.nodeIds) await this._client._sendMayFail("DOM.removeNode", { nodeId });
     await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
     try {
-      await this._page._frameManager.frame(this._targetId)._context("utility");
+      await this._page.frameManager.frame(this._targetId)._context("utility");
     } catch {
     }
     ;
@@ -578,28 +592,29 @@ class FrameSession {
     if (this._eventBelongsToStaleFrame(payload.frameId))
       return;
     if (payload.disposition === "currentTab")
-      this._page._frameManager.frameRequestedNavigation(payload.frameId);
+      this._page.frameManager.frameRequestedNavigation(payload.frameId);
   }
   _onFrameNavigatedWithinDocument(frameId, url) {
     if (this._eventBelongsToStaleFrame(frameId))
       return;
-    this._page._frameManager.frameCommittedSameDocumentNavigation(frameId, url);
+    this._page.frameManager.frameCommittedSameDocumentNavigation(frameId, url);
   }
   _onFrameDetached(frameId, reason) {
     if (this._crPage._sessions.has(frameId)) {
       return;
     }
     if (reason === "swap") {
-      const frame = this._page._frameManager.frame(frameId);
+      const frame = this._page.frameManager.frame(frameId);
       if (frame)
-        this._page._frameManager.removeChildFramesRecursively(frame);
+        this._page.frameManager.removeChildFramesRecursively(frame);
       return;
     }
-    this._page._frameManager.frameDetached(frameId);
+    this._page.frameManager.frameDetached(frameId);
   }
   _onExecutionContextCreated(contextPayload) {
-    for (const name of this._exposedBindingNames) this._client._sendMayFail("Runtime.addBinding", { name, executionContextId: contextPayload.id });
-    const frame = contextPayload.auxData ? this._page._frameManager.frame(contextPayload.auxData.frameId) : null;
+    for (const name of this._exposedBindingNames)
+      this._client._sendMayFail("Runtime.addBinding", { name, executionContextId: contextPayload.id });
+    const frame = contextPayload.auxData ? this._page.frameManager.frame(contextPayload.auxData.frameId) : null;
     if (contextPayload.auxData.type == "worker") throw new Error("ExecutionContext is worker");
     if (!frame || this._eventBelongsToStaleFrame(frame._id))
       return;
@@ -632,10 +647,10 @@ class FrameSession {
     const session = this._client.createChildSession(event.sessionId);
     if (event.targetInfo.type === "iframe") {
       const targetId = event.targetInfo.targetId;
-      const frame = this._page._frameManager.frame(targetId);
+      const frame = this._page.frameManager.frame(targetId);
       if (!frame)
         return;
-      this._page._frameManager.removeChildFramesRecursively(frame);
+      this._page.frameManager.removeChildFramesRecursively(frame);
       for (const [contextId, context] of this._contextIdToContext) {
         if (context.frame === frame)
           this._onExecutionContextDestroyed(contextId);
@@ -651,11 +666,11 @@ class FrameSession {
       return;
     }
     const url = event.targetInfo.url;
-    const worker = new import_page2.Worker(this._page, url);
-    this._page._addWorker(event.sessionId, worker);
+    const worker = new import_page.Worker(this._page, url);
+    this._page.addWorker(event.sessionId, worker);
     this._workerSessions.set(event.sessionId, session);
     session.once("Runtime.executionContextCreated", async (event2) => {
-      worker._createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event2.context));
+      worker.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event2.context));
     });
     var globalThis = await session._sendMayFail("Runtime.evaluate", {
       expression: "globalThis",
@@ -664,17 +679,25 @@ class FrameSession {
     if (globalThis && globalThis.result) {
       var globalThisObjId = globalThis.result.objectId;
       var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
-      worker._createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, { id: executionContextId }));
+      worker.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, { id: executionContextId }));
     }
-    this._crPage._networkManager.addSession(session, this._page._frameManager.frame(this._targetId) ?? void 0).catch(() => {
+    this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? void 0).catch(() => {
     });
     session._sendMayFail("Runtime.runIfWaitingForDebugger");
-    session._sendMayFail("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
+    session._sendMayFail("Target.setAutoAttach", {
+      autoAttach: true,
+      waitForDebuggerOnStart: true,
+      flatten: true,
+      filter: [
+        { type: "worker" },
+        { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
+      ]
+    });
     session.on("Target.attachedToTarget", (event2) => this._onAttachedToTarget(event2));
     session.on("Target.detachedFromTarget", (event2) => this._onDetachedFromTarget(event2));
     session.on("Runtime.consoleAPICalled", (event2) => {
-      const args = event2.args.map((o) => (0, import_crExecutionContext.createHandle)(worker._existingExecutionContext, o));
-      this._page._addConsoleMessage(event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
+      const args = event2.args.map((o) => (0, import_crExecutionContext.createHandle)(worker.existingExecutionContext, o));
+      this._page.addConsoleMessage(event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
     });
     session.on("Runtime.exceptionThrown", (exception) => this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, (0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails), this._page));
   }
@@ -682,7 +705,7 @@ class FrameSession {
     const workerSession = this._workerSessions.get(event.sessionId);
     if (workerSession) {
       workerSession.dispose();
-      this._page._removeWorker(event.sessionId);
+      this._page.removeWorker(event.sessionId);
       return;
     }
     const childFrameSession = this._crPage._sessions.get(event.targetId);
@@ -694,7 +717,7 @@ class FrameSession {
     }
     this._client.send("Page.enable").catch((e) => null).then(() => {
       if (!childFrameSession._swappedIn)
-        this._page._frameManager.frameDetached(event.targetId);
+        this._page.frameManager.frameDetached(event.targetId);
       childFrameSession.dispose();
     });
   }
@@ -709,26 +732,26 @@ class FrameSession {
     if (!context)
       return;
     const values = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(context, arg));
-    this._page._addConsoleMessage(event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    this._page.addConsoleMessage(event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
   }
   async _onBindingCalled(event) {
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
     if (!(pageOrError instanceof Error)) {
       const context = this._contextIdToContext.get(event.executionContextId);
-      if (context) await this._page._onBindingCalled(event.payload, context);
-      else await this._page._onBindingCalled(event.payload, await this._page.mainFrame()._mainContext());
+      if (context)
+        await this._page.onBindingCalled(event.payload, context);
     }
   }
   _onDialog(event) {
-    if (!this._page._frameManager.frame(this._targetId))
+    if (!this._page.frameManager.frame(this._targetId))
       return;
-    this._page.emitOnContext(import_browserContext.BrowserContext.Events.Dialog, new dialog.Dialog(
+    this._page.browserContext.dialogManager.dialogDidOpen(new dialog.Dialog(
       this._page,
       event.type,
       event.message,
       async (accept, promptText) => {
         if (this._isMainFrame() && event.type === "beforeunload" && !accept)
-          this._page._frameManager.frameAbortedNavigation(this._page.mainFrame()._id, "navigation cancelled by beforeunload dialog");
+          this._page.frameManager.frameAbortedNavigation(this._page.mainFrame()._id, "navigation cancelled by beforeunload dialog");
         await this._client.send("Page.handleJavaScriptDialog", { accept, promptText });
       },
       event.defaultPrompt
@@ -751,13 +774,13 @@ class FrameSession {
         lineNumber: lineNumber || 0,
         columnNumber: 0
       };
-      this._page._addConsoleMessage(level, [], location, text);
+      this._page.addConsoleMessage(level, [], location, text);
     }
   }
   async _onFileChooserOpened(event) {
     if (!event.backendNodeId)
       return;
-    const frame = this._page._frameManager.frame(event.frameId);
+    const frame = this._page.frameManager.frame(event.frameId);
     if (!frame)
       return;
     let handle;
@@ -780,7 +803,7 @@ class FrameSession {
       });
     });
     const buffer = Buffer.from(payload.data, "base64");
-    this._page.emit(import_page2.Page.Events.ScreencastFrame, {
+    this._page.emit(import_page.Page.Events.ScreencastFrame, {
       buffer,
       frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : void 0,
       width: payload.metadata.deviceWidth,
@@ -789,14 +812,14 @@ class FrameSession {
   }
   async _createVideoRecorder(screencastId, options) {
     (0, import_assert.assert)(!this._screencastId);
-    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.attribution.playwright.options.sdkLanguage);
+    const ffmpegPath = import_registry.registry.findExecutable("ffmpeg").executablePathOrDie(this._page.browserContext._browser.sdkLanguage());
     this._videoRecorder = await import_videoRecorder.VideoRecorder.launch(this._crPage._page, ffmpegPath, options);
     this._screencastId = screencastId;
   }
   async _startVideoRecording(options) {
     const screencastId = this._screencastId;
     (0, import_assert.assert)(screencastId);
-    this._page.once(import_page2.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
+    this._page.once(import_page.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
     }));
     const gotFirstFrame = new Promise((f) => this._client.once("Page.screencastFrame", f));
     await this._startScreencast(this._videoRecorder, {
@@ -843,7 +866,7 @@ class FrameSession {
     (0, import_assert.assert)(this._isMainFrame());
     const options = this._crPage._browserContext._options;
     const emulatedSize = this._page.emulatedSize();
-    if (emulatedSize === null)
+    if (!emulatedSize)
       return;
     const viewportSize = emulatedSize.viewport;
     const screenSize = emulatedSize.screen;
@@ -860,9 +883,7 @@ class FrameSession {
     };
     if (JSON.stringify(this._metricsOverride) === JSON.stringify(metricsOverride))
       return;
-    const promises = [
-      this._client.send("Emulation.setDeviceMetricsOverride", metricsOverride)
-    ];
+    const promises = [];
     if (!preserveWindowBoundaries && this._windowId) {
       let insets = { width: 0, height: 0 };
       if (this._crPage._browserContext._browser.options.headful) {
@@ -882,6 +903,7 @@ class FrameSession {
         height: viewportSize.height + insets.height
       }));
     }
+    promises.push(this._client.send("Emulation.setDeviceMetricsOverride", metricsOverride));
     await Promise.all(promises);
     this._metricsOverride = metricsOverride;
   }
@@ -931,19 +953,22 @@ class FrameSession {
     await this._client.send("Page.setInterceptFileChooserDialog", { enabled }).catch(() => {
     });
   }
-  async _evaluateOnNewDocument(initScript, world) {
+  async _evaluateOnNewDocument(initScript, world, runImmediately) {
     this._evaluateOnNewDocumentScripts.push(initScript);
   }
-  async _removeEvaluatesOnNewDocument() {
+  async _removeEvaluatesOnNewDocument(initScripts) {
     this._evaluateOnNewDocumentScripts = [];
   }
+  async exposePlaywrightBinding() {
+    await this._client.send("Runtime.addBinding", { name: import_page.PageBinding.kBindingName });
+  }
   async _getContentFrame(handle) {
     const nodeInfo = await this._client.send("DOM.describeNode", {
       objectId: handle._objectId
     });
     if (!nodeInfo || typeof nodeInfo.node.frameId !== "string")
       return null;
-    return this._page._frameManager.frame(nodeInfo.node.frameId);
+    return this._page.frameManager.frame(nodeInfo.node.frameId);
   }
   async _getOwnerFrame(handle) {
     const documentElement = await handle.evaluateHandle((node) => {
@@ -980,7 +1005,7 @@ class FrameSession {
     return { x: x + position.x, y: y + position.y, width, height };
   }
   async _framePosition() {
-    const frame = this._page._frameManager.frame(this._targetId);
+    const frame = this._page.frameManager.frame(this._targetId);
     if (!frame)
       return null;
     if (frame === this._page.mainFrame())
@@ -1093,7 +1118,7 @@ function calculateUserAgentMetadata(options) {
   const metadata = {
     mobile: !!options.isMobile,
     model: "",
-    architecture: "x64",
+    architecture: "x86",
     platform: "Windows",
     platformVersion: ""
   };

package/lib/server/chromium/crServiceWorker.js

@@ -40,11 +40,11 @@ class CRServiceWorker extends import_page.Worker {
   constructor(browserContext, session, url) {
     super(browserContext, url);
     this._session = session;
-    this._browserContext = browserContext;
+    this.browserContext = browserContext;
     if (!!process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS)
       this._networkManager = new import_crNetworkManager.CRNetworkManager(null, this);
     session.once("Runtime.executionContextCreated", (event) => {
-      this._createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event.context));
+      this.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event.context));
     });
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
       this.updateRequestInterception();
@@ -73,19 +73,19 @@ class CRServiceWorker extends import_page.Worker {
   async updateOffline() {
     if (!this._isNetworkInspectionEnabled())
       return;
-    await this._networkManager?.setOffline(!!this._browserContext._options.offline).catch(() => {
+    await this._networkManager?.setOffline(!!this.browserContext._options.offline).catch(() => {
     });
   }
   async updateHttpCredentials() {
     if (!this._isNetworkInspectionEnabled())
       return;
-    await this._networkManager?.authenticate(this._browserContext._options.httpCredentials || null).catch(() => {
+    await this._networkManager?.authenticate(this.browserContext._options.httpCredentials || null).catch(() => {
     });
   }
   async updateExtraHTTPHeaders() {
     if (!this._isNetworkInspectionEnabled())
       return;
-    await this._networkManager?.setExtraHTTPHeaders(this._browserContext._options.extraHTTPHeaders || []).catch(() => {
+    await this._networkManager?.setExtraHTTPHeaders(this.browserContext._options.extraHTTPHeaders || []).catch(() => {
     });
   }
   async updateRequestInterception() {
@@ -95,29 +95,24 @@ class CRServiceWorker extends import_page.Worker {
     });
   }
   needsRequestInterception() {
-    return this._isNetworkInspectionEnabled() && !!this._browserContext._requestInterceptor;
+    return this._isNetworkInspectionEnabled() && this.browserContext.requestInterceptors.length > 0;
   }
   reportRequestFinished(request, response) {
-    this._browserContext.emit(import_browserContext.BrowserContext.Events.RequestFinished, { request, response });
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.RequestFinished, { request, response });
   }
   requestFailed(request, _canceled) {
-    this._browserContext.emit(import_browserContext.BrowserContext.Events.RequestFailed, request);
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.RequestFailed, request);
   }
   requestReceivedResponse(response) {
-    this._browserContext.emit(import_browserContext.BrowserContext.Events.Response, response);
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.Response, response);
   }
   requestStarted(request, route) {
-    this._browserContext.emit(import_browserContext.BrowserContext.Events.Request, request);
-    if (route) {
-      const r = new network.Route(request, route);
-      if (this._browserContext._requestInterceptor?.(r, request))
-        return;
-      r.continue({ isFallback: true }).catch(() => {
-      });
-    }
+    this.browserContext.emit(import_browserContext.BrowserContext.Events.Request, request);
+    if (route)
+      new network.Route(request, route).handle(this.browserContext.requestInterceptors);
   }
   _isNetworkInspectionEnabled() {
-    return this._browserContext._options.serviceWorkers !== "block";
+    return this.browserContext._options.serviceWorkers !== "block";
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/server/chromium/videoRecorder.js

@@ -22,13 +22,11 @@ __export(videoRecorder_exports, {
 });
 module.exports = __toCommonJS(videoRecorder_exports);
 var import_utils = require("../../utils");
-var import_instrumentation = require("../instrumentation");
 var import_page = require("../page");
 var import_processLauncher = require("../utils/processLauncher");
-var import_progress = require("../progress");
 const fps = 25;
 class VideoRecorder {
-  constructor(page, ffmpegPath, progress) {
+  constructor(page, ffmpegPath) {
     this._process = null;
     this._gracefullyClose = null;
     this._lastWritePromise = Promise.resolve();
@@ -37,46 +35,40 @@ class VideoRecorder {
     this._lastWriteTimestamp = 0;
     this._frameQueue = [];
     this._isStopped = false;
-    this._progress = progress;
     this._ffmpegPath = ffmpegPath;
     page.on(import_page.Page.Events.ScreencastFrame, (frame) => this.writeFrame(frame.buffer, frame.frameSwapWallTime / 1e3));
   }
   static async launch(page, ffmpegPath, options) {
     if (!options.outputFile.endsWith(".webm"))
       throw new Error("File must have .webm extension");
-    const controller = new import_progress.ProgressController((0, import_instrumentation.serverSideCallMetadata)(), page);
-    controller.setLogName("browser");
-    return await controller.run(async (progress) => {
-      const recorder = new VideoRecorder(page, ffmpegPath, progress);
-      await recorder._launch(options);
-      return recorder;
-    });
+    const recorder = new VideoRecorder(page, ffmpegPath);
+    await recorder._launch(options);
+    return recorder;
   }
   async _launch(options) {
     const w = options.width;
     const h = options.height;
     const args = `-loglevel error -f image2pipe -avioflags direct -fpsprobesize 0 -probesize 32 -analyzeduration 0 -c:v mjpeg -i pipe:0 -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -deadline realtime -speed 8 -b:v 1M -threads 1 -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(" ");
     args.push(options.outputFile);
-    const progress = this._progress;
     const { launchedProcess, gracefullyClose } = await (0, import_processLauncher.launchProcess)({
       command: this._ffmpegPath,
       args,
       stdio: "stdin",
-      log: (message) => progress.log(message),
+      log: (message) => import_utils.debugLogger.log("browser", message),
       tempDirectories: [],
       attemptToGracefullyClose: async () => {
-        progress.log("Closing stdin...");
+        import_utils.debugLogger.log("browser", "Closing stdin...");
         launchedProcess.stdin.end();
       },
       onExit: (exitCode, signal) => {
-        progress.log(`ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
+        import_utils.debugLogger.log("browser", `ffmpeg onkill exitCode=${exitCode} signal=${signal}`);
       }
     });
     launchedProcess.stdin.on("finish", () => {
-      progress.log("ffmpeg finished input.");
+      import_utils.debugLogger.log("browser", "ffmpeg finished input.");
     });
     launchedProcess.stdin.on("error", () => {
-      progress.log("ffmpeg error.");
+      import_utils.debugLogger.log("browser", "ffmpeg error.");
     });
     this._process = launchedProcess;
     this._gracefullyClose = gracefullyClose;
@@ -103,7 +95,7 @@ class VideoRecorder {
   async _sendFrame(frame) {
     return new Promise((f) => this._process.stdin.write(frame, f)).then((error) => {
       if (error)
-        this._progress.log(`ffmpeg failed to write: ${String(error)}`);
+        import_utils.debugLogger.log("browser", `ffmpeg failed to write: ${String(error)}`);
     });
   }
   async stop() {