patchright-core 1.58.2 → 1.59.1

package/lib/server/chromium/crPage.js

@@ -31,7 +31,6 @@ __export(crPage_exports, {
   CRPage: () => CRPage
 });
 module.exports = __toCommonJS(crPage_exports);
-var import_crypto = __toESM(require("crypto"));
 var import_assert = require("../../utils/isomorphic/assert");
 var import_eventsHelper = require("../utils/eventsHelper");
 var import_stackTrace = require("../../utils/isomorphic/stackTrace");
@@ -41,6 +40,7 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
+var import_browserContext = require("../browserContext");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -51,6 +51,7 @@ var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
 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();
@@ -75,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) {
@@ -110,7 +110,7 @@ class CRPage {
     while (!this._sessions.has(frame._id)) {
       const parent = frame.parentFrame();
       if (!parent)
-        throw new Error(`Frame was detached`);
+        throw new Error(`Frame has been detached.`);
       frame = parent;
     }
     return this._sessions.get(frame._id);
@@ -185,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() {
@@ -204,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,
@@ -217,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 }));
@@ -235,16 +234,18 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async startScreencast(options) {
-    await this._mainFrameSession._client.send("Page.startScreencast", {
+  startScreencast(options) {
+    this._mainFrameSession._client.send("Page.startScreencast", {
       format: "jpeg",
       quality: options.quality,
       maxWidth: options.width,
       maxHeight: options.height
+    }).catch(() => {
     });
   }
-  async stopScreencast() {
-    await this._mainFrameSession._client._sendMayFail("Page.stopScreencast");
+  stopScreencast() {
+    this._mainFrameSession._client._sendMayFail("Page.stopScreencast").catch(() => {
+    });
   }
   rafCountForStablePosition() {
     return 1;
@@ -296,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 {
@@ -319,10 +315,6 @@ class FrameSession {
     this._swappedIn = false;
     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;
@@ -368,37 +360,36 @@ class FrameSession {
     ]);
   }
   async _initialize(hasUIWindow) {
-    const pageEnablePromise = this._client.send("Page.enable");
     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 videoOptions;
-    if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
-      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
+    if (this._isMainFrame() && hasUIWindow && !this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._crPage._page);
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
-    let bufferedDialogEvents = this._isMainFrame() ? [] : void 0;
-    if (bufferedDialogEvents)
-      this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.javascriptDialogOpening", (event) => bufferedDialogEvents ? bufferedDialogEvents.push(event) : void 0));
     this._addBrowserListeners();
     this._bufferedAttachedToTargetEvents = [];
     const promises = [
-      pageEnablePromise,
+      this._client.send("Page.enable"),
       this._client.send("Page.getFrameTree").then(({ frameTree }) => {
         if (this._isMainFrame()) {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
-          const pendingDialogEvents = bufferedDialogEvents || [];
-          bufferedDialogEvents = void 0;
-          for (const event of pendingDialogEvents)
-            this._onDialog(event);
         }
         const attachedToTargetEvents = this._bufferedAttachedToTargetEvents || [];
         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) => {
@@ -406,26 +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").catch(() => {
-            });
-            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.source).catch((e) => {
-              });
-            for (const source of this._crPage._page.initScripts)
-              frame.evaluateExpression(source.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
@@ -436,7 +414,7 @@ class FrameSession {
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
         promises.push(this.exposePlaywrightBinding());
-      if (this._isMainFrame() && !this._crPage._browserContext._options.focusControl)
+      if (this._isMainFrame())
         promises.push(this._client.send("Emulation.setFocusEmulationEnabled", { enabled: true }));
       const options = this._crPage._browserContext._options;
       if (options.bypassCSP)
@@ -460,11 +438,13 @@ 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 (videoOptions)
-        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
+      for (const initScript of this._crPage._page.allInitScripts())
+        promises.push(this._evaluateOnNewDocument(
+          initScript,
+          "main",
+          true
+          /* runImmediately */
+        ));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
@@ -489,32 +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");
-    if (event.name !== "load") {
-      await this._client._sendMayFail("Runtime.runIfWaitingForDebugger");
-      return;
-    }
-    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);
@@ -545,35 +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");
-    if (!initial) {
-      try {
-        await this._page.frameManager.frame(this._targetId)._context("utility");
-      } catch {
-      }
-      ;
-      return;
-    }
-    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))
@@ -599,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 && (worldName === "main" || worldName === "utility"))
+    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);
@@ -630,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;
@@ -666,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");
@@ -687,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)));
   }
@@ -722,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();
@@ -764,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) {
@@ -788,15 +712,14 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.screencast.throttleFrameAck(() => {
-      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
-    });
     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 : Date.now(),
-      width: payload.metadata.deviceWidth,
-      height: payload.metadata.deviceHeight
+      viewportWidth: payload.metadata.deviceWidth,
+      viewportHeight: payload.metadata.deviceHeight
+    }, () => {
+      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
     });
   }
   async _updateGeolocation(initial) {
@@ -880,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) {
@@ -898,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 });
@@ -1001,30 +936,6 @@ class FrameSession {
       throw new Error(dom.kUnableToAdoptErrorMessage);
     return (0, import_crExecutionContext.createHandle)(to, result.object).asElement();
   }
-  async _initBinding(binding = import_page.PageBinding) {
-    this._exposedBindingNames.push(binding.name);
-    this._exposedBindingScripts.push(binding.source);
-    const contextIds = Array.from(this._contextIdToContext.keys());
-    await Promise.all([
-      this._client._sendMayFail("Runtime.addBinding", { name: binding.name }),
-      ...contextIds.map((executionContextId) => this._client._sendMayFail("Runtime.addBinding", { name: binding.name, executionContextId }))
-    ]);
-    for (const contextId of contextIds) {
-      this._client._sendMayFail("Runtime.evaluate", {
-        expression: binding.source,
-        contextId,
-        awaitPromise: true
-      });
-    }
-  }
-  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 {
@@ -1046,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);