patchright-core 1.58.2 → 1.59.1

package/lib/server/dispatchers/pageDispatcher.js

@@ -34,9 +34,12 @@ var import_networkDispatchers = require("./networkDispatchers");
 var import_networkDispatchers2 = require("./networkDispatchers");
 var import_networkDispatchers3 = require("./networkDispatchers");
 var import_webSocketRouteDispatcher = require("./webSocketRouteDispatcher");
+var import_disposableDispatcher = require("./disposableDispatcher");
 var import_instrumentation = require("../instrumentation");
 var import_urlMatch = require("../../utils/isomorphic/urlMatch");
-var import_pageAgentDispatcher = require("./pageAgentDispatcher");
+var import_recorder = require("../recorder");
+var import_disposable = require("../disposable");
+var import_videoRecorder = require("../videoRecorder");
 class PageDispatcher extends import_dispatcher.Dispatcher {
   constructor(parentScope, page) {
     const mainFrame = import_frameDispatcher.FrameDispatcher.from(parentScope, page.mainFrame());
@@ -44,14 +47,14 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
       mainFrame,
       viewportSize: page.emulatedSize()?.viewport,
       isClosed: page.isClosed(),
-      opener: PageDispatcher.fromNullable(parentScope, page.opener())
+      opener: PageDispatcher.fromNullable(parentScope, page.opener()),
+      video: page.video ? createVideoDispatcher(parentScope, page.video) : void 0
     });
     this._type_EventTarget = true;
     this._type_Page = true;
     this._subscriptions = /* @__PURE__ */ new Set();
     this._webSocketInterceptionPatterns = [];
-    this._bindings = [];
-    this._initScripts = [];
+    this._disposables = [];
     this._interceptionUrlMatchers = [];
     this._locatorHandlers = /* @__PURE__ */ new Set();
     this._jsCoverageActive = false;
@@ -85,9 +88,6 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     this.addObjectListener(import_page.Page.Events.LocatorHandlerTriggered, (uid) => this._dispatchEvent("locatorHandlerTriggered", { uid }));
     this.addObjectListener(import_page.Page.Events.WebSocket, (webSocket) => this._dispatchEvent("webSocket", { webSocket: new import_networkDispatchers3.WebSocketDispatcher(this, webSocket) }));
     this.addObjectListener(import_page.Page.Events.Worker, (worker) => this._dispatchEvent("worker", { worker: new WorkerDispatcher(this, worker) }));
-    this.addObjectListener(import_page.Page.Events.Video, (artifact) => this._dispatchEvent("video", { artifact: import_artifactDispatcher.ArtifactDispatcher.from(parentScope, artifact) }));
-    if (page.video)
-      this._dispatchEvent("video", { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this.parentScope(), page.video) });
     const frames = page.frameManager.frames();
     for (let i = 1; i < frames.length; i++)
       this._onFrameAttached(frames[i]);
@@ -112,7 +112,8 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
       this._dispatchEvent("bindingCall", { binding: binding2 });
       return binding2.promise();
     });
-    this._bindings.push(binding);
+    this._disposables.push(binding);
+    return { disposable: new import_disposableDispatcher.DisposableDispatcher(this, binding) };
   }
   async setExtraHTTPHeaders(params, progress) {
     await this._page.setExtraHTTPHeaders(progress, params.headers);
@@ -154,7 +155,9 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     await this._page.setViewportSize(progress, params.viewportSize);
   }
   async addInitScript(params, progress) {
-    this._initScripts.push(await this._page.addInitScript(progress, params.source));
+    const initScript = await this._page.addInitScript(params.source);
+    this._disposables.push(initScript);
+    return { disposable: new import_disposableDispatcher.DisposableDispatcher(this, initScript) };
   }
   async setNetworkInterceptionPatterns(params, progress) {
     const hadMatchers = this._interceptionUrlMatchers.length > 0;
@@ -163,7 +166,7 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
         await this._page.removeRequestInterceptor(this._requestInterceptor);
       this._interceptionUrlMatchers = [];
     } else {
-      this._interceptionUrlMatchers = params.patterns.map((pattern) => pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob);
+      this._interceptionUrlMatchers = params.patterns.map(import_urlMatch.deserializeURLMatch);
       if (!hadMatchers)
         await this._page.addRequestInterceptor(progress, this._requestInterceptor);
     }
@@ -209,49 +212,51 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
       this._subscriptions.delete(params.event);
   }
   async keyboardDown(params, progress) {
-    await this._page.keyboard.down(progress, params.key);
+    await this._page.keyboard.apiDown(progress, params.key);
   }
   async keyboardUp(params, progress) {
-    await this._page.keyboard.up(progress, params.key);
+    await this._page.keyboard.apiUp(progress, params.key);
   }
   async keyboardInsertText(params, progress) {
-    await this._page.keyboard.insertText(progress, params.text);
+    await this._page.keyboard.apiInsertText(progress, params.text);
   }
   async keyboardType(params, progress) {
-    await this._page.keyboard.type(progress, params.text, params);
+    await this._page.keyboard.apiType(progress, params.text, params);
   }
   async keyboardPress(params, progress) {
-    await this._page.keyboard.press(progress, params.key, params);
+    await this._page.keyboard.apiPress(progress, params.key, params);
+  }
+  async clearConsoleMessages(params, progress) {
+    this._page.clearConsoleMessages();
   }
   async consoleMessages(params, progress) {
     this._subscriptions.add("console");
-    return { messages: this._page.consoleMessages().map((message) => this.parentScope().serializeConsoleMessage(message, this)) };
+    return { messages: this._page.consoleMessages(params.filter).map((message) => this.parentScope().serializeConsoleMessage(message, this)) };
+  }
+  async clearPageErrors(params, progress) {
+    this._page.clearPageErrors();
   }
   async pageErrors(params, progress) {
-    return { errors: this._page.pageErrors().map((error) => (0, import_errors.serializeError)(error)) };
+    return { errors: this._page.pageErrors(params.filter).map((error) => (0, import_errors.serializeError)(error)) };
   }
   async mouseMove(params, progress) {
-    progress.metadata.point = { x: params.x, y: params.y };
-    await this._page.mouse.move(progress, params.x, params.y, params);
+    await this._page.mouse.apiMove(progress, params.x, params.y, params);
   }
   async mouseDown(params, progress) {
-    progress.metadata.point = this._page.mouse.currentPoint();
-    await this._page.mouse.down(progress, params);
+    await this._page.mouse.apiDown(progress, params);
   }
   async mouseUp(params, progress) {
-    progress.metadata.point = this._page.mouse.currentPoint();
-    await this._page.mouse.up(progress, params);
+    await this._page.mouse.apiUp(progress, params);
   }
   async mouseClick(params, progress) {
-    progress.metadata.point = { x: params.x, y: params.y };
-    await this._page.mouse.click(progress, params.x, params.y, params);
+    await this._page.mouse.apiClick(progress, params.x, params.y, params);
   }
   async mouseWheel(params, progress) {
-    await this._page.mouse.wheel(progress, params.deltaX, params.deltaY);
+    await this._page.mouse.apiWheel(progress, params.deltaX, params.deltaY);
   }
   async touchscreenTap(params, progress) {
     progress.metadata.point = { x: params.x, y: params.y };
-    await this._page.touchscreen.tap(progress, params.x, params.y);
+    await this._page.touchscreen.apiTap(progress, params.x, params.y);
   }
   async pdf(params, progress) {
     if (!this._page.pdf)
@@ -263,12 +268,69 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     this._subscriptions.add("request");
     return { requests: this._page.networkRequests().map((request) => import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request)) };
   }
-  async snapshotForAI(params, progress) {
-    return await this._page.snapshotForAI(progress, params);
-  }
   async bringToFront(params, progress) {
     await progress.race(this._page.bringToFront());
   }
+  async pickLocator(params, progress) {
+    const recorder = await import_recorder.Recorder.forContext(this._page.browserContext, { omitCallTracking: true, hideToolbar: true });
+    const selector = await recorder.pickLocator(progress, this._page);
+    return { selector };
+  }
+  async cancelPickLocator(params, progress) {
+    const recorder = await import_recorder.Recorder.existingForContext(this._page.browserContext);
+    await recorder?.setMode("none");
+  }
+  async screencastShowOverlay(params) {
+    const id = await this._page.overlay.show(params.html, params.duration);
+    return { id };
+  }
+  async screencastRemoveOverlay(params) {
+    await this._page.overlay.remove(params.id);
+  }
+  async screencastChapter(params) {
+    await this._page.overlay.chapter(params);
+  }
+  async screencastSetOverlayVisible(params) {
+    await this._page.overlay.setVisible(params.visible);
+  }
+  async screencastShowActions(params) {
+    this._page.screencast.showActions({ duration: params.duration, position: params.position, fontSize: params.fontSize });
+  }
+  async screencastHideActions() {
+    this._page.screencast.hideActions();
+  }
+  async screencastStart(params, progress) {
+    if (this._screencastClient || this._videoRecorder)
+      throw new Error("Screencast is already running");
+    if (params.sendFrames) {
+      this._screencastClient = {
+        onFrame: (frame) => {
+          this._dispatchEvent("screencastFrame", { data: frame.buffer });
+        },
+        dispose: () => {
+        },
+        size: params.size,
+        quality: params.quality
+      };
+      this._page.screencast.addClient(this._screencastClient);
+    }
+    let artifact;
+    if (params.record) {
+      this._videoRecorder = new import_videoRecorder.VideoRecorder(this._page.screencast);
+      artifact = this._videoRecorder.start(params);
+    }
+    return { artifact: artifact ? createVideoDispatcher(this.parentScope(), artifact) : void 0 };
+  }
+  async screencastStop(params, progress) {
+    if (this._videoRecorder) {
+      await this._videoRecorder.stop();
+      this._videoRecorder = void 0;
+    }
+    const client = this._screencastClient;
+    this._screencastClient = void 0;
+    if (client)
+      this._page.screencast.removeClient(client);
+  }
   async startJSCoverage(params, progress) {
     const coverage = this._page.coverage;
     await coverage.startJSCoverage(progress, params);
@@ -289,9 +351,6 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     const coverage = this._page.coverage;
     return await coverage.stopCSSCoverage();
   }
-  async agent(params, progress) {
-    return { agent: new import_pageAgentDispatcher.PageAgentDispatcher(this, params) };
-  }
   _onFrameAttached(frame) {
     this._dispatchEvent("frameAttached", { frame: import_frameDispatcher.FrameDispatcher.from(this.parentScope(), frame) });
   }
@@ -304,12 +363,8 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
     this._interceptionUrlMatchers = [];
     this._page.removeRequestInterceptor(this._requestInterceptor).catch(() => {
     });
-    this._page.removeExposedBindings(this._bindings).catch(() => {
-    });
-    this._bindings = [];
-    this._page.removeInitScripts(this._initScripts).catch(() => {
+    (0, import_disposable.disposeAll)(this._disposables).catch(() => {
     });
-    this._initScripts = [];
     if (this._routeWebSocketInitScript)
       import_webSocketRouteDispatcher.WebSocketRouteDispatcher.uninstall(this.connection, this._page, this._routeWebSocketInitScript).catch(() => {
       });
@@ -327,6 +382,11 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
       this._page.coverage.stopCSSCoverage().catch(() => {
       });
     this._cssCoverageActive = false;
+    this.screencastStop({}, void 0).catch(() => {
+    });
+  }
+  async setDockTile(params) {
+    await this._page.setDockTile(params.image);
   }
 }
 class WorkerDispatcher extends import_dispatcher.Dispatcher {
@@ -385,6 +445,9 @@ class BindingCallDispatcher extends import_dispatcher.Dispatcher {
     this._dispose();
   }
 }
+function createVideoDispatcher(parentScope, video) {
+  return import_artifactDispatcher.ArtifactDispatcher.from(parentScope.parentScope(), video);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BindingCallDispatcher,

package/lib/server/dispatchers/webSocketRouteDispatcher.js

@@ -101,7 +101,7 @@ class WebSocketRouteDispatcher extends import_dispatcher.Dispatcher {
       }, data);
     }
     ++data.counter;
-    return await target.addInitScript(progress, `
+    return await target.addInitScript(`
       (() => {
         const module = {};
         ${rawWebSocketMockSource.source}
@@ -115,8 +115,8 @@ class WebSocketRouteDispatcher extends import_dispatcher.Dispatcher {
     if (!data || data.connection !== connection)
       return;
     if (--data.counter <= 0)
-      await context.removeExposedBindings([data.binding]);
-    await target.removeInitScripts([initScript]);
+      await data.binding.dispose();
+    await initScript.dispose();
   }
   async connect(params, progress) {
     await this._evaluateAPIRequest(progress, { id: this._id, type: "connect" });
@@ -152,8 +152,7 @@ class WebSocketRouteDispatcher extends import_dispatcher.Dispatcher {
 }
 function matchesPattern(dispatcher, baseURL, url) {
   for (const pattern of dispatcher._webSocketInterceptionPatterns || []) {
-    const urlMatch = pattern.regexSource ? new RegExp(pattern.regexSource, pattern.regexFlags) : pattern.glob;
-    if ((0, import_urlMatch.urlMatches)(baseURL, url, urlMatch, true))
+    if ((0, import_urlMatch.urlMatches)(baseURL, url, (0, import_urlMatch.deserializeURLMatch)(pattern), true))
       return true;
   }
   return false;

package/lib/server/disposable.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var disposable_exports = {};
+__export(disposable_exports, {
+  DisposableObject: () => DisposableObject,
+  disposeAll: () => disposeAll
+});
+module.exports = __toCommonJS(disposable_exports);
+var import_instrumentation = require("./instrumentation");
+class DisposableObject extends import_instrumentation.SdkObject {
+  constructor(parent) {
+    super(parent, "disposable");
+    this.parent = parent;
+  }
+}
+async function disposeAll(disposables) {
+  const copy = [...disposables];
+  disposables.length = 0;
+  await Promise.all(copy.map((d) => d.dispose()));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DisposableObject,
+  disposeAll
+});

package/lib/server/dom.js

@@ -202,17 +202,17 @@ class ElementHandle extends js.JSHandle {
     );
   }
   async _clickablePoint() {
-    const intersectQuadWithViewport = (quad) => {
-      return quad.map((point) => ({
+    const intersectQuadWithViewport = (quad2) => {
+      return quad2.map((point) => ({
         x: Math.min(Math.max(point.x, 0), metrics.width),
         y: Math.min(Math.max(point.y, 0), metrics.height)
       }));
     };
-    const computeQuadArea = (quad) => {
+    const computeQuadArea = (quad2) => {
       let area = 0;
-      for (let i = 0; i < quad.length; ++i) {
-        const p1 = quad[i];
-        const p2 = quad[(i + 1) % quad.length];
+      for (let i = 0; i < quad2.length; ++i) {
+        const p1 = quad2[i];
+        const p2 = quad2[(i + 1) % quad2.length];
         area += (p1.x * p2.y - p2.x * p1.y) / 2;
       }
       return Math.abs(area);
@@ -225,17 +225,19 @@ class ElementHandle extends js.JSHandle {
       return quads;
     if (!quads || !quads.length)
       return "error:notvisible";
-    const filtered = quads.map((quad) => intersectQuadWithViewport(quad)).filter((quad) => computeQuadArea(quad) > 0.99);
+    const filtered = quads.map((quad2) => intersectQuadWithViewport(quad2)).filter((quad2) => computeQuadArea(quad2) > 0.99);
     if (!filtered.length)
       return "error:notinviewport";
+    const quad = filtered[0];
+    const box = quadToRect(quad);
     if (this._page.browserContext._browser.options.name === "firefox") {
-      for (const quad of filtered) {
-        const integerPoint = findIntegerPointInsideQuad(quad);
+      for (const q of filtered) {
+        const integerPoint = findIntegerPointInsideQuad(q);
         if (integerPoint)
-          return integerPoint;
+          return { point: integerPoint, box };
       }
     }
-    return quadMiddlePoint(filtered[0]);
+    return { point: quadMiddlePoint(quad), box };
   }
   async _offsetPoint(offset) {
     const [box, border] = await Promise.all([
@@ -248,8 +250,11 @@ class ElementHandle extends js.JSHandle {
     if (border === "error:notconnected")
       return border;
     return {
-      x: box.x + border.left + offset.x,
-      y: box.y + border.top + offset.y
+      point: {
+        x: box.x + border.left + offset.x,
+        y: box.y + border.top + offset.y
+      },
+      box
     };
   }
   async _retryAction(progress, actionName, action, options) {
@@ -360,11 +365,12 @@ class ElementHandle extends js.JSHandle {
     if (scrolled !== "done")
       return scrolled;
     progress.log("  done scrolling");
-    const maybePoint = position ? await progress.race(this._offsetPoint(position)) : await progress.race(this._clickablePoint());
-    if (typeof maybePoint === "string")
-      return maybePoint;
-    const point = roundPoint(maybePoint);
+    const maybeResult = position ? await progress.race(this._offsetPoint(position)) : await progress.race(this._clickablePoint());
+    if (typeof maybeResult === "string")
+      return maybeResult;
+    const point = roundPoint(maybeResult.point);
     progress.metadata.point = point;
+    progress.metadata.box = maybeResult.box;
     await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
     let hitTargetInterceptionHandle;
     if (force) {
@@ -470,10 +476,15 @@ class ElementHandle extends js.JSHandle {
     const result = await this._selectOption(progress, elements, values, options);
     return throwRetargetableDOMError(result);
   }
+  async _beforeNonPointerAction(progress) {
+    if (progress.metadata.annotate)
+      progress.metadata.box = await this.boundingBox() || void 0;
+    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+  }
   async _selectOption(progress, elements, values, options) {
     let resultingOptions = [];
     const result = await this._retryAction(progress, "select option", async () => {
-      await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+      await this._beforeNonPointerAction(progress);
       if (!options.force)
         progress.log(`  waiting for element to be visible and enabled`);
       const optionsToSelect = [...elements, ...values];
@@ -504,7 +515,7 @@ class ElementHandle extends js.JSHandle {
   async _fill(progress, value, options) {
     progress.log(`  fill("${value}")`);
     return await this._retryAction(progress, "fill", async () => {
-      await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+      await this._beforeNonPointerAction(progress);
       if (!options.force)
         progress.log("  waiting for element to be visible, enabled and editable");
       const result = await progress.race(this.evaluateInUtility(async ([injected, node, { value: value2, force }]) => {
@@ -517,7 +528,7 @@ class ElementHandle extends js.JSHandle {
       }, { value, force: options.force }));
       if (result === "needsinput") {
         if (value)
-          await this._page.keyboard.insertText(progress, value);
+          await this._page.keyboard._insertText(progress, value);
         else
           await this._page.keyboard.press(progress, "Delete");
         return "done";
@@ -568,7 +579,7 @@ class ElementHandle extends js.JSHandle {
     if (result === "error:notconnected" || !result.asElement())
       return "error:notconnected";
     const retargeted = result.asElement();
-    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+    await this._beforeNonPointerAction(progress);
     if (localPaths || localDirectory) {
       const localPathsOrDirectory = localDirectory ? [localDirectory] : localPaths;
       await progress.race(Promise.all(localPathsOrDirectory.map((localPath) => import_fs.default.promises.access(localPath, import_fs.default.constants.F_OK))));
@@ -601,7 +612,7 @@ class ElementHandle extends js.JSHandle {
   }
   async _type(progress, text, options) {
     progress.log(`elementHandle.type("${text}")`);
-    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+    await this._beforeNonPointerAction(progress);
     const result = await this._focus(
       progress,
       true
@@ -619,7 +630,7 @@ class ElementHandle extends js.JSHandle {
   }
   async _press(progress, key, options) {
     progress.log(`elementHandle.press("${key}")`);
-    await progress.race(this.instrumentation.onBeforeInputAction(this, progress.metadata));
+    await this._beforeNonPointerAction(progress);
     return this._page.frameManager.waitForSignalsCreatedBy(progress, !options.noWaitAfter, async () => {
       const result = await this._focus(
         progress,
@@ -666,9 +677,6 @@ class ElementHandle extends js.JSHandle {
   async boundingBox() {
     return this._page.delegate.getBoundingBox(this);
   }
-  async ariaSnapshot() {
-    return await this.evaluateInUtility(([injected, element]) => injected.ariaSnapshot(element, { mode: "expect" }), {});
-  }
   async screenshot(progress, options) {
     return await this._page.screenshotter.screenshotElement(progress, this, options);
   }
@@ -767,6 +775,16 @@ function roundPoint(point) {
     y: (point.y * 100 | 0) / 100
   };
 }
+function quadToRect(quad) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const point of quad) {
+    minX = Math.min(minX, point.x);
+    minY = Math.min(minY, point.y);
+    maxX = Math.max(maxX, point.x);
+    maxY = Math.max(maxY, point.y);
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
 function quadMiddlePoint(quad) {
   const result = { x: 0, y: 0 };
   for (const point of quad) {

package/lib/server/download.js

@@ -36,9 +36,10 @@ var import_page = require("./page");
 var import_utils = require("../utils");
 var import_artifact = require("./artifact");
 class Download {
-  constructor(page, downloadsPath, uuid, url, suggestedFilename) {
+  constructor(page, downloadsPath, uuid, url, suggestedFilename, downloadFilename) {
     const unaccessibleErrorMessage = page.browserContext._options.acceptDownloads === "deny" ? "Pass { acceptDownloads: true } when you are creating your browser context." : void 0;
-    this.artifact = new import_artifact.Artifact(page, import_path.default.join(downloadsPath, uuid), unaccessibleErrorMessage, () => {
+    const downloadPath = import_path.default.join(downloadsPath, downloadFilename ?? uuid);
+    this.artifact = new import_artifact.Artifact(page, downloadPath, unaccessibleErrorMessage, () => {
       return this._page.browserContext.cancelDownload(uuid);
     });
     this._page = page;

package/lib/server/electron/electron.js

@@ -76,7 +76,6 @@ class ElectronApplication extends import_instrumentation.SdkObject {
     this._nodeSession.on("Runtime.consoleAPICalled", (event) => this._onConsoleAPI(event));
     const appClosePromise = new Promise((f) => this.once(ElectronApplication.Events.Close, f));
     this._browserContext.setCustomCloseHandler(async () => {
-      await this._browserContext.stopVideoRecording();
       const electronHandle = await this._nodeElectronHandlePromise;
       await electronHandle.evaluate(({ app }) => app.quit()).catch(() => {
       });
@@ -97,7 +96,7 @@ class ElectronApplication extends import_instrumentation.SdkObject {
     if (!this._nodeExecutionContext)
       return;
     const args = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(this._nodeExecutionContext, arg));
-    const message = new import_console.ConsoleMessage(null, null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    const message = new import_console.ConsoleMessage(null, null, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace), event.timestamp);
     this.emit(ElectronApplication.Events.Console, message);
   }
   async initialize() {
@@ -131,11 +130,17 @@ class Electron extends import_instrumentation.SdkObject {
     let app = void 0;
     let electronArguments = ["--inspect=0", "--remote-debugging-port=0", ...options.args || []];
     if (import_os.default.platform() === "linux") {
-      const runningAsRoot = process.geteuid && process.geteuid() === 0;
-      if (runningAsRoot && electronArguments.indexOf("--no-sandbox") === -1)
+      if (!options.chromiumSandbox && electronArguments.indexOf("--no-sandbox") === -1)
         electronArguments.unshift("--no-sandbox");
     }
-    const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
+    let artifactsDir;
+    const tempDirectories = [];
+    if (options.artifactsDir) {
+      artifactsDir = options.artifactsDir;
+    } else {
+      artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
+      tempDirectories.push(artifactsDir);
+    }
     const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
     const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
     let command;
@@ -173,7 +178,7 @@ class Electron extends import_instrumentation.SdkObject {
       shell,
       stdio: "pipe",
       cwd: options.cwd,
-      tempDirectories: [artifactsDir],
+      tempDirectories,
       attemptToGracefullyClose: () => app.close(),
       handleSIGINT: true,
       handleSIGTERM: true,
@@ -219,7 +224,7 @@ class Electron extends import_instrumentation.SdkObject {
       };
       const browserOptions = {
         name: "electron",
-        isChromium: true,
+        browserType: "chromium",
         headful: true,
         persistent: contextOptions,
         browserProcess,

package/lib/server/firefox/ffBrowser.js

@@ -35,7 +35,6 @@ module.exports = __toCommonJS(ffBrowser_exports);
 var import_utils = require("../../utils");
 var import_browser = require("../browser");
 var import_browserContext = require("../browserContext");
-var import_errors = require("../errors");
 var network = __toESM(require("../network"));
 var import_ffConnection = require("./ffConnection");
 var import_ffPage = require("./ffPage");
@@ -128,7 +127,7 @@ class FFBrowser extends import_browser.Browser {
     ffPage._page.frameManager.frameAbortedNavigation(payload.frameId, "Download is starting");
     let originPage = ffPage._page.initializedOrUndefined();
     if (!originPage) {
-      ffPage._markAsError(new Error("Starting new page download"));
+      ffPage._reportAsNew(new Error("Starting new page download"));
       if (ffPage._opener)
         originPage = ffPage._opener._page.initializedOrUndefined();
     }
@@ -141,9 +140,6 @@ class FFBrowser extends import_browser.Browser {
     this._downloadFinished(payload.uuid, error);
   }
   _onDisconnect() {
-    for (const video of this._idToVideo.values())
-      video.artifact.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
-    this._idToVideo.clear();
     for (const ffPage of this._ffPages.values())
       ffPage.didClose();
     this._ffPages.clear();
@@ -173,8 +169,11 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
     promises.push(this.doUpdateDefaultViewport());
     if (this._options.hasTouch)
       promises.push(this._browser.session.send("Browser.setTouchOverride", { browserContextId, hasTouch: true }));
-    if (this._options.userAgent)
+    if (this._options.userAgent) {
       promises.push(this._browser.session.send("Browser.setUserAgentOverride", { browserContextId, userAgent: this._options.userAgent }));
+      const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)(this._options);
+      promises.push(this._browser.session.send("Browser.setPlatformOverride", { browserContextId, platform: navigatorPlatform || null }));
+    }
     if (this._options.bypassCSP)
       promises.push(this._browser.session.send("Browser.setBypassCSP", { browserContextId, bypassCSP: true }));
     if (this._options.ignoreHTTPSErrors || this._options.internalIgnoreHTTPSErrors)
@@ -194,16 +193,6 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
     if (this._options.offline)
       promises.push(this.doUpdateOffline());
     promises.push(this.doUpdateDefaultEmulatedMedia());
-    if (this._options.recordVideo) {
-      promises.push(this._browser.session.send("Browser.setScreencastOptions", {
-        // validateBrowserContextOptions ensures correct video size.
-        options: {
-          ...this._options.recordVideo.size,
-          quality: 90
-        },
-        browserContextId: this._browserContextId
-      }));
-    }
     const proxy = this._options.proxyOverride || this._options.proxy;
     if (proxy) {
       promises.push(this._browser.session.send("Browser.setContextProxy", {
@@ -270,7 +259,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
       ["geolocation", "geo"],
       ["persistent-storage", "persistent-storage"],
       ["push", "push"],
-      ["notifications", "desktop-notification"]
+      ["notifications", "desktop-notification"],
+      ["screen-wake-lock", "screen-wake-lock"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -296,6 +286,8 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async setUserAgent(userAgent) {
     await this._browser.session.send("Browser.setUserAgentOverride", { browserContextId: this._browserContextId, userAgent: userAgent || null });
+    const { navigatorPlatform } = (0, import_browserContext.calculateUserAgentEmulation)({ userAgent });
+    await this._browser.session.send("Browser.setPlatformOverride", { browserContextId: this._browserContextId, platform: navigatorPlatform || null });
   }
   async doUpdateOffline() {
     await this._browser.session.send("Browser.setOnlineOverride", { browserContextId: this._browserContextId, override: this._options.offline ? "offline" : "online" });
@@ -373,8 +365,6 @@ class FFBrowserContext extends import_browserContext.BrowserContext {
   }
   async doClose(reason) {
     if (!this._browserContextId) {
-      if (this._options.recordVideo)
-        await Promise.all(this._ffPages().map((ffPage) => ffPage._page.screencast.stopVideoRecording()));
       await this._browser.close({ reason });
     } else {
       await this._browser.session.send("Browser.removeBrowserContext", { browserContextId: this._browserContextId });