patchright-core 1.57.0 → 1.59.0

package/lib/server/chromium/crPage.js

@@ -31,10 +31,7 @@ __export(crPage_exports, {
   CRPage: () => CRPage
 });
 module.exports = __toCommonJS(crPage_exports);
-var import_crypto = __toESM(require("crypto"));
-var import_path = __toESM(require("path"));
 var import_assert = require("../../utils/isomorphic/assert");
-var import_crypto2 = require("../utils/crypto");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
 var dialog = __toESM(require("../dialog"));
@@ -43,7 +40,7 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
-var import_registry = require("../registry");
+var import_browserContext = require("../browserContext");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -52,9 +49,9 @@ var import_crNetworkManager = require("./crNetworkManager");
 var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
-var import_videoRecorder = require("./videoRecorder");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
+var import_videoRecorder = require("../videoRecorder");
 class CRPage {
   constructor(client, targetId, browserContext, opener, bits) {
     this._sessions = /* @__PURE__ */ new Map();
@@ -79,8 +76,7 @@ class CRPage {
     this.updateOffline();
     this.updateExtraHTTPHeaders();
     this.updateHttpCredentials();
-    this._networkManager.setRequestInterception(true);
-    this.initScriptTag = import_crypto.default.randomBytes(20).toString("hex");
+    this.updateRequestInterception();
     this._mainFrameSession = new FrameSession(this, client, targetId, null);
     this._sessions.set(targetId, this._mainFrameSession);
     if (opener && !browserContext._options.noDefaultViewport) {
@@ -189,7 +185,6 @@ class CRPage {
     await this._mainFrameSession._client.send("HeapProfiler.collectGarbage");
   }
   async addInitScript(initScript, world = "main") {
-    this._page.initScripts.push(initScript);
     await this._forAllFrameSessions((frame) => frame._evaluateOnNewDocument(initScript, world));
   }
   async exposePlaywrightBinding() {
@@ -208,7 +203,7 @@ class CRPage {
     await this._mainFrameSession._client.send("Emulation.setDefaultBackgroundColorOverride", { color });
   }
   async takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, scale) {
-    const { visualViewport } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
+    const { visualViewport, contentSize, cssContentSize } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
     if (!documentRect) {
       documentRect = {
         x: visualViewport.pageX + viewportRect.x,
@@ -221,7 +216,7 @@ class CRPage {
     }
     const clip = { ...documentRect, scale: viewportRect ? visualViewport.scale : 1 };
     if (scale === "css") {
-      const deviceScaleFactor = this._browserContext._options.deviceScaleFactor || 1;
+      const deviceScaleFactor = this._mainFrameSession._metricsOverride?.deviceScaleFactor || contentSize.width / cssContentSize.width || 1;
       clip.scale /= deviceScaleFactor;
     }
     const result = await progress.race(this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport }));
@@ -239,17 +234,18 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async setScreencastOptions(options) {
-    if (options) {
-      await this._mainFrameSession._startScreencast(this, {
-        format: "jpeg",
-        quality: options.quality,
-        maxWidth: options.width,
-        maxHeight: options.height
-      });
-    } else {
-      await this._mainFrameSession._stopScreencast(this);
-    }
+  startScreencast(options) {
+    this._mainFrameSession._client.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: options.quality,
+      maxWidth: options.width,
+      maxHeight: options.height
+    }).catch(() => {
+    });
+  }
+  stopScreencast() {
+    this._mainFrameSession._client._sendMayFail("Page.stopScreencast").catch(() => {
+    });
   }
   rafCountForStablePosition() {
     return 1;
@@ -301,13 +297,8 @@ class CRPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return false;
   }
-  async exposeBinding(binding) {
-    await this._forAllFrameSessions((frame) => frame._initBinding(binding));
-    await Promise.all(this._page.frames().map((frame) => frame.evaluateExpression(binding.source).catch((e) => {
-    })));
-  }
-  async removeExposedBindings() {
-    await this._forAllFrameSessions((frame) => frame._removeExposedBindings());
+  async setDockTile(image) {
+    await this._mainFrameSession._client.send("Browser.setDockTile", { image: image.toString("base64") });
   }
 }
 class FrameSession {
@@ -322,15 +313,8 @@ class FrameSession {
     // Marks the oopif session that remote -> local transition has happened in the parent.
     // See Target.detachedFromTarget handler for details.
     this._swappedIn = false;
-    this._videoRecorder = null;
-    this._screencastId = null;
-    this._screencastClients = /* @__PURE__ */ new Set();
     this._workerSessions = /* @__PURE__ */ new Map();
     this._initScriptIds = /* @__PURE__ */ new Map();
-    this._exposedBindingNames = [];
-    this._evaluateOnNewDocumentScripts = [];
-    this._parsedExecutionContextIds = [];
-    this._exposedBindingScripts = [];
     this._client = client;
     this._crPage = crPage;
     this._page = crPage._page;
@@ -380,23 +364,8 @@ class FrameSession {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let screencastOptions;
-    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 = {
-        // validateBrowserContextOptions ensures correct video size.
-        ...this._crPage._browserContext._options.recordVideo.size,
-        outputFile
-      };
-      await this._crPage._browserContext._ensureVideosPath();
-      await this._createVideoRecorder(screencastId, screencastOptions);
-      this._crPage._page.waitForInitializedOrError().then((p) => {
-        if (p instanceof Error)
-          this._stopVideoRecording().catch(() => {
-          });
-      });
-    }
+    if (this._isMainFrame() && hasUIWindow && !this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._crPage._page);
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -413,6 +382,14 @@ class FrameSession {
         this._bufferedAttachedToTargetEvents = void 0;
         for (const event of attachedToTargetEvents)
           this._onAttachedToTarget(event);
+        const localFrames = this._isMainFrame() ? this._page.frames() : [this._page.frameManager.frame(this._targetId)];
+        for (const frame of localFrames) {
+          this._client._sendMayFail("Page.createIsolatedWorld", {
+            frameId: frame._id,
+            grantUniveralAccess: true,
+            worldName: this._crPage.utilityWorldName
+          });
+        }
         const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ":";
         if (isInitialEmptyPage) {
           lifecycleEventsEnabled.catch((e) => {
@@ -420,22 +397,13 @@ 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)];
-          for (const frame of localFrames) {
-            this._page.frameManager.frame(frame._id)._context("utility");
-            for (const binding of this._crPage._browserContext._pageBindings.values())
-              frame.evaluateExpression(binding.source).catch((e) => {
-              });
-            for (const source of this._crPage._browserContext.initScripts)
-              frame.evaluateExpression(source).catch((e) => {
-              });
-          }
           this._firstNonInitialNavigationCommittedFulfill();
           this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.lifecycleEvent", (event) => this._onLifecycleEvent(event)));
         }
       }),
       this._client.send("Log.enable", {}),
       lifecycleEventsEnabled = this._client.send("Page.setLifecycleEventsEnabled", { enabled: true }),
+      this._client.send("Runtime.enable", {}),
       this._client.send("Page.addScriptToEvaluateOnNewDocument", {
         source: "",
         worldName: this._crPage.utilityWorldName
@@ -446,6 +414,8 @@ class FrameSession {
     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;
       if (options.bypassCSP)
         promises.push(this._client.send("Page.setBypassCSP", { enabled: true }));
@@ -468,21 +438,20 @@ class FrameSession {
       promises.push(this._updateGeolocation(true));
       promises.push(this._updateEmulateMedia());
       promises.push(this._updateFileChooserInterception(true));
-      for (const binding of this._crPage._page.allBindings()) promises.push(this._initBinding(binding));
-      for (const initScript of this._crPage._browserContext.initScripts) promises.push(this._evaluateOnNewDocument(initScript, "main"));
-      for (const initScript of this._crPage._page.initScripts) promises.push(this._evaluateOnNewDocument(initScript, "main"));
-      if (screencastOptions)
-        promises.push(this._startVideoRecording(screencastOptions));
+      for (const initScript of this._crPage._page.allInitScripts())
+        promises.push(this._evaluateOnNewDocument(
+          initScript,
+          "main",
+          true
+          /* runImmediately */
+        ));
     }
-    if (!(this._crPage._page._pageBindings.size || this._crPage._browserContext._pageBindings.size))
-      promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
+    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");
   }
   dispose() {
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     for (const childSession of this._childSessions)
       childSession.dispose();
     if (this._parentSession)
@@ -500,28 +469,13 @@ class FrameSession {
       throw new frames.NavigationAbortedError(response.loaderId, `${response.errorText} at ${url}`);
     return { newDocumentId: response.loaderId };
   }
-  async _onLifecycleEvent(event) {
+  _onLifecycleEvent(event) {
     if (this._eventBelongsToStaleFrame(event.frameId))
       return;
     if (event.name === "load")
       this._page.frameManager.frameLifecycleEvent(event.frameId, "load");
     else if (event.name === "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;
-    var query = await this._client._sendMayFail("DOM.querySelectorAll", {
-      nodeId: document.root.nodeId,
-      selector: "[class=" + this._crPage.initScriptTag + "]"
-    });
-    if (!query) return;
-    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");
-    } catch {
-    }
-    ;
   }
   _handleFrameTree(frameTree) {
     this._onFrameAttached(frameTree.frame.id, frameTree.frame.parentId || null);
@@ -552,27 +506,12 @@ class FrameSession {
     }
     this._page.frameManager.frameAttached(frameId, parentFrameId);
   }
-  async _onFrameNavigated(framePayload, initial) {
+  _onFrameNavigated(framePayload, initial) {
     if (this._eventBelongsToStaleFrame(framePayload.id))
       return;
     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");
-    var document = await this._client._sendMayFail("DOM.getDocument");
-    if (!document) return;
-    var query = await this._client._sendMayFail("DOM.querySelectorAll", {
-      nodeId: document.root.nodeId,
-      selector: "[class=" + this._crPage.initScriptTag + "]"
-    });
-    if (!query) return;
-    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");
-    } catch {
-    }
-    ;
   }
   _onFrameRequestedNavigation(payload) {
     if (this._eventBelongsToStaleFrame(payload.frameId))
@@ -598,25 +537,19 @@ class FrameSession {
     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;
-    if (contextPayload.auxData.type == "worker") throw new Error("ExecutionContext is worker");
     if (!frame || this._eventBelongsToStaleFrame(frame._id))
       return;
     const delegate = new import_crExecutionContext.CRExecutionContext(this._client, contextPayload);
-    let worldName = contextPayload.name;
+    let worldName = null;
+    if (contextPayload.auxData && !!contextPayload.auxData.isDefault)
+      worldName = "main";
+    else if (contextPayload.name === this._crPage.utilityWorldName)
+      worldName = "utility";
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
     if (worldName)
       frame._contextCreated(worldName, context);
     this._contextIdToContext.set(contextPayload.id, context);
-    for (const source of this._exposedBindingScripts) {
-      this._client._sendMayFail("Runtime.evaluate", {
-        expression: source,
-        contextId: contextPayload.id,
-        awaitPromise: true
-      });
-    }
   }
   _onExecutionContextDestroyed(executionContextId) {
     const context = this._contextIdToContext.get(executionContextId);
@@ -629,7 +562,7 @@ class FrameSession {
     for (const contextId of Array.from(this._contextIdToContext.keys()))
       this._onExecutionContextDestroyed(contextId);
   }
-  async _onAttachedToTarget(event) {
+  _onAttachedToTarget(event) {
     if (this._bufferedAttachedToTargetEvents) {
       this._bufferedAttachedToTargetEvents.push(event);
       return;
@@ -665,19 +598,11 @@ class FrameSession {
     session.once("Runtime.executionContextCreated", async (event2) => {
       worker.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event2.context));
     });
-    var globalThis = await session._sendMayFail("Runtime.evaluate", {
-      expression: "globalThis",
-      serializationOptions: { serialization: "idOnly" }
-    });
-    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 }));
-    }
     if (this._crPage._browserContext._browser.majorVersion() >= 143)
       session.on("Inspector.workerScriptLoaded", () => worker.workerScriptLoaded());
     else
       worker.workerScriptLoaded();
+    session._sendMayFail("Runtime.enable");
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? void 0).catch(() => {
     });
     session._sendMayFail("Runtime.runIfWaitingForDebugger");
@@ -686,7 +611,7 @@ class FrameSession {
     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(worker, event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
+      this._page.addConsoleMessage(worker, event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace), void 0, event2.timestamp);
     });
     session.on("Runtime.exceptionThrown", (exception) => this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails)));
   }
@@ -721,7 +646,7 @@ class FrameSession {
     if (!context)
       return;
     const values = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(context, arg));
-    this._page.addConsoleMessage(null, event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    this._page.addConsoleMessage(null, event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace), void 0, event.timestamp);
   }
   async _onBindingCalled(event) {
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
@@ -763,7 +688,7 @@ class FrameSession {
         lineNumber: lineNumber || 0,
         columnNumber: 0
       };
-      this._page.addConsoleMessage(null, level, [], location, text);
+      this._page.addConsoleMessage(null, level, [], location, text, event.entry.timestamp);
     }
   }
   async _onFileChooserOpened(event) {
@@ -787,63 +712,16 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.throttleScreencastFrameAck(() => {
-      this._client.send("Page.screencastFrameAck", { sessionId: payload.sessionId }).catch(() => {
-      });
-    });
     const buffer = Buffer.from(payload.data, "base64");
-    this._page.emit(import_page.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
-      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : void 0,
-      width: payload.metadata.deviceWidth,
-      height: payload.metadata.deviceHeight
-    });
-  }
-  async _createVideoRecorder(screencastId, options) {
-    (0, import_assert.assert)(!this._screencastId);
-    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_page.Page.Events.Close, () => this._stopVideoRecording().catch(() => {
-    }));
-    const gotFirstFrame = new Promise((f) => this._client.once("Page.screencastFrame", f));
-    await this._startScreencast(this._videoRecorder, {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: options.width,
-      maxHeight: options.height
-    });
-    gotFirstFrame.then(() => {
-      this._crPage._browserContext._browser._videoStarted(this._crPage._browserContext, screencastId, options.outputFile, this._crPage._page.waitForInitializedOrError());
+      frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : Date.now(),
+      viewportWidth: payload.metadata.deviceWidth,
+      viewportHeight: payload.metadata.deviceHeight
+    }, () => {
+      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
     });
   }
-  async _stopVideoRecording() {
-    if (!this._screencastId)
-      return;
-    const screencastId = this._screencastId;
-    this._screencastId = null;
-    const recorder = this._videoRecorder;
-    this._videoRecorder = null;
-    await this._stopScreencast(recorder);
-    await recorder.stop().catch(() => {
-    });
-    const video = this._crPage._browserContext._browser._takeVideo(screencastId);
-    video?.reportFinished();
-  }
-  async _startScreencast(client, options = {}) {
-    this._screencastClients.add(client);
-    if (this._screencastClients.size === 1)
-      await this._client.send("Page.startScreencast", options);
-  }
-  async _stopScreencast(client) {
-    this._screencastClients.delete(client);
-    if (!this._screencastClients.size)
-      await this._client._sendMayFail("Page.stopScreencast");
-  }
   async _updateGeolocation(initial) {
     const geolocation = this._crPage._browserContext._options.geolocation;
     if (!initial || geolocation)
@@ -925,10 +803,12 @@ class FrameSession {
   }
   async _updateUserAgent() {
     const options = this._crPage._browserContext._options;
+    const { navigatorPlatform, userAgentMetadata } = (0, import_browserContext.calculateUserAgentEmulation)(options);
     await this._client.send("Emulation.setUserAgentOverride", {
       userAgent: options.userAgent || "",
       acceptLanguage: options.locale,
-      userAgentMetadata: calculateUserAgentMetadata(options)
+      platform: navigatorPlatform,
+      userAgentMetadata
     });
   }
   async _setDefaultFontFamilies(session) {
@@ -943,10 +823,20 @@ class FrameSession {
     });
   }
   async _evaluateOnNewDocument(initScript, world, runImmediately) {
-    this._evaluateOnNewDocumentScripts.push(initScript);
+    const worldName = world === "utility" ? this._crPage.utilityWorldName : void 0;
+    const { identifier } = await this._client.send("Page.addScriptToEvaluateOnNewDocument", { source: initScript.source, worldName, runImmediately });
+    this._initScriptIds.set(initScript, identifier);
   }
   async _removeEvaluatesOnNewDocument(initScripts) {
-    this._evaluateOnNewDocumentScripts = [];
+    const ids = [];
+    for (const script of initScripts) {
+      const id = this._initScriptIds.get(script);
+      if (id)
+        ids.push(id);
+      this._initScriptIds.delete(script);
+    }
+    await Promise.all(ids.map((identifier) => this._client.send("Page.removeScriptToEvaluateOnNewDocument", { identifier }).catch(() => {
+    })));
   }
   async exposePlaywrightBinding() {
     await this._client.send("Runtime.addBinding", { name: import_page.PageBinding.kBindingName });
@@ -1046,39 +936,6 @@ class FrameSession {
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return (0, import_crExecutionContext.createHandle)(to, result.object).asElement();
   }
-  async _initBinding(binding = import_page.PageBinding) {
-    var result = await this._client._sendMayFail("Page.createIsolatedWorld", {
-      frameId: this._targetId,
-      grantUniveralAccess: true,
-      worldName: "utility"
-    });
-    if (!result) return;
-    var isolatedContextId = result.executionContextId;
-    var globalThis = await this._client._sendMayFail("Runtime.evaluate", {
-      expression: "globalThis",
-      serializationOptions: { serialization: "idOnly" }
-    });
-    if (!globalThis) return;
-    var globalThisObjId = globalThis["result"]["objectId"];
-    var mainContextId = parseInt(globalThisObjId.split(".")[1], 10);
-    await Promise.all([
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: mainContextId }),
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId: isolatedContextId })
-      // this._client._sendMayFail("Runtime.evaluate", { expression: binding.source, contextId: mainContextId, awaitPromise: true })
-    ]);
-    this._exposedBindingNames.push(binding.name);
-    this._exposedBindingScripts.push(binding.source);
-    await this._crPage.addInitScript(binding.source);
-  }
-  async _removeExposedBindings() {
-    const toRetain = [];
-    const toRemove = [];
-    for (const name of this._exposedBindingNames)
-      (name.startsWith("__pw_") ? toRetain : toRemove).push(name);
-    this._exposedBindingNames = toRetain;
-    await Promise.all(toRemove.map((name) => this._client.send("Runtime.removeBinding", { name })));
-  }
 }
 async function emulateLocale(session, locale) {
   try {
@@ -1100,49 +957,6 @@ async function emulateTimezone(session, timezoneId) {
     throw exception;
   }
 }
-function calculateUserAgentMetadata(options) {
-  const ua = options.userAgent;
-  if (!ua)
-    return void 0;
-  const metadata = {
-    mobile: !!options.isMobile,
-    model: "",
-    architecture: "x86",
-    platform: "Windows",
-    platformVersion: ""
-  };
-  const androidMatch = ua.match(/Android (\d+(\.\d+)?(\.\d+)?)/);
-  const iPhoneMatch = ua.match(/iPhone OS (\d+(_\d+)?)/);
-  const iPadMatch = ua.match(/iPad; CPU OS (\d+(_\d+)?)/);
-  const macOSMatch = ua.match(/Mac OS X (\d+(_\d+)?(_\d+)?)/);
-  const windowsMatch = ua.match(/Windows\D+(\d+(\.\d+)?(\.\d+)?)/);
-  if (androidMatch) {
-    metadata.platform = "Android";
-    metadata.platformVersion = androidMatch[1];
-    metadata.architecture = "arm";
-  } else if (iPhoneMatch) {
-    metadata.platform = "iOS";
-    metadata.platformVersion = iPhoneMatch[1];
-    metadata.architecture = "arm";
-  } else if (iPadMatch) {
-    metadata.platform = "iOS";
-    metadata.platformVersion = iPadMatch[1];
-    metadata.architecture = "arm";
-  } else if (macOSMatch) {
-    metadata.platform = "macOS";
-    metadata.platformVersion = macOSMatch[1];
-    if (!ua.includes("Intel"))
-      metadata.architecture = "arm";
-  } else if (windowsMatch) {
-    metadata.platform = "Windows";
-    metadata.platformVersion = windowsMatch[1];
-  } else if (ua.toLowerCase().includes("linux")) {
-    metadata.platform = "Linux";
-  }
-  if (ua.includes("ARM"))
-    metadata.architecture = "arm";
-  return metadata;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRPage

package/lib/server/chromium/crServiceWorker.js

@@ -45,13 +45,14 @@ class CRServiceWorker extends import_page.Worker {
     this.browserContext = browserContext;
     if (!process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK)
       this._networkManager = new import_crNetworkManager.CRNetworkManager(null, this);
-    session.once("Runtime.executionContextCreated", (event) => {
+    session.on("Inspector.targetCrashed", () => this._prepareContextForRestart());
+    session.on("Runtime.executionContextCreated", (event) => {
       this.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event.context));
+      if (this.browserContext._browser.majorVersion() < 143)
+        this.workerScriptLoaded();
     });
     if (this.browserContext._browser.majorVersion() >= 143)
       session.on("Inspector.workerScriptLoaded", () => this.workerScriptLoaded());
-    else
-      this.workerScriptLoaded();
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
       this.updateRequestInterception();
       this.updateExtraHTTPHeaders();
@@ -69,24 +70,16 @@ class CRServiceWorker extends import_page.Worker {
       if (!this.existingExecutionContext || process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_CONSOLE)
         return;
       const args = event.args.map((o) => (0, import_crExecutionContext.createHandle)(this.existingExecutionContext, o));
-      const message = new import_console.ConsoleMessage(null, this, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+      const message = new import_console.ConsoleMessage(null, this, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace), event.timestamp);
       this.browserContext.emit(import_browserContext.BrowserContext.Events.Console, message);
     });
+    session.send("Runtime.enable", {}).catch((e) => {
+    });
     session.send("Runtime.runIfWaitingForDebugger").catch((e) => {
     });
     session.on("Inspector.targetReloadedAfterCrash", () => {
       session._sendMayFail("Runtime.runIfWaitingForDebugger", {});
     });
-    session._sendMayFail("Runtime.evaluate", {
-      expression: "globalThis",
-      serializationOptions: { serialization: "idOnly" }
-    }).then((globalThis) => {
-      if (globalThis && globalThis.result) {
-        var globalThisObjId = globalThis.result.objectId;
-        var executionContextId = parseInt(globalThisObjId.split(".")[1], 10);
-        this.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, { id: executionContextId }));
-      }
-    });
   }
   didClose() {
     this._networkManager?.removeSession(this._session);