patchright-core 1.57.0 → 1.59.0

package/lib/client/harRouter.js

@@ -52,9 +52,21 @@ class HarRouter {
     if (response.action === "fulfill") {
       if (response.status === -1)
         return;
+      const transformedHeaders = response.headers.reduce((headersMap, { name, value }) => {
+        if (name.toLowerCase() !== "set-cookie") {
+          headersMap[name] = value;
+        } else {
+          if (!headersMap["set-cookie"])
+            headersMap["set-cookie"] = value;
+          else
+            headersMap["set-cookie"] += `
+${value}`;
+        }
+        return headersMap;
+      }, {});
       await route.fulfill({
         status: response.status,
-        headers: Object.fromEntries(response.headers.map((h) => [h.name, h.value])),
+        headers: transformedHeaders,
         body: response.body
       });
       return;

package/lib/client/jsHandle.js

@@ -36,16 +36,12 @@ class JSHandle extends import_channelOwner.ChannelOwner {
     this._preview = this._initializer.preview;
     this._channel.on("previewUpdated", ({ preview }) => this._preview = preview);
   }
-  async evaluate(pageFunction, arg, isolatedContext = true) {
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
+  async evaluate(pageFunction, arg) {
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return parseResult(result.value);
   }
-  async _evaluateFunction(functionDeclaration) {
-    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: serializeArgument(void 0) });
-    return parseResult(result.value);
-  }
-  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg), isolatedContext });
+  async evaluateHandle(pageFunction, arg) {
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: serializeArgument(arg) });
     return JSHandle.from(result.handle);
   }
   async getProperty(propertyName) {

package/lib/client/locator.js

@@ -24,7 +24,6 @@ __export(locator_exports, {
   testIdAttributeName: () => testIdAttributeName
 });
 module.exports = __toCommonJS(locator_exports);
-var import_jsHandle = require("./jsHandle");
 var import_elementHandle = require("./elementHandle");
 var import_locatorGenerators = require("../utils/isomorphic/locatorGenerators");
 var import_locatorUtils = require("../utils/isomorphic/locatorUtils");
@@ -98,37 +97,14 @@ class Locator {
       ...options
     });
   }
-  async evaluate(pageFunction, arg, options, isolatedContext = true) {
-    return await this._withElement(
-      async (h) => (0, import_jsHandle.parseResult)(
-        (await h._channel.evaluateExpression({
-          expression: String(pageFunction),
-          isFunction: typeof pageFunction === "function",
-          arg: (0, import_jsHandle.serializeArgument)(arg),
-          isolatedContext
-        })).value
-      ),
-      { title: "Evaluate", timeout: options?.timeout }
-    );
-  }
-  async _evaluateFunction(functionDeclaration, options) {
-    return await this._withElement((h) => h._evaluateFunction(functionDeclaration), { title: "Evaluate", timeout: options?.timeout });
-  }
-  async evaluateAll(pageFunction, arg, isolatedContext = true) {
-    return await this._frame.$$eval(this._selector, pageFunction, arg, isolatedContext);
-  }
-  async evaluateHandle(pageFunction, arg, options, isolatedContext = true) {
-    return await this._withElement(
-      async (h) => import_jsHandle.JSHandle.from(
-        (await h._channel.evaluateExpressionHandle({
-          expression: String(pageFunction),
-          isFunction: typeof pageFunction === "function",
-          arg: (0, import_jsHandle.serializeArgument)(arg),
-          isolatedContext
-        })).handle
-      ),
-      { title: "Evaluate", timeout: options?.timeout }
-    );
+  async evaluate(pageFunction, arg, options) {
+    return await this._withElement((h) => h.evaluate(pageFunction, arg), { title: "Evaluate", timeout: options?.timeout });
+  }
+  async evaluateAll(pageFunction, arg) {
+    return await this._frame.$$eval(this._selector, pageFunction, arg);
+  }
+  async evaluateHandle(pageFunction, arg, options) {
+    return await this._withElement((h) => h.evaluateHandle(pageFunction, arg), { title: "Evaluate", timeout: options?.timeout });
   }
   async fill(value, options = {}) {
     return await this._frame.fill(this._selector, value, { strict: true, ...options });
@@ -220,8 +196,9 @@ class Locator {
   async count(_options) {
     return await this._frame._queryCount(this._selector, _options);
   }
-  async _resolveSelector() {
-    return await this._frame._channel.resolveSelector({ selector: this._selector });
+  async normalize() {
+    const { resolvedSelector } = await this._frame._channel.resolveSelector({ selector: this._selector });
+    return new Locator(this._frame, resolvedSelector);
   }
   async getAttribute(name, options) {
     return await this._frame.getAttribute(this._selector, name, { strict: true, ...options });
@@ -263,8 +240,8 @@ class Locator {
     const mask = options.mask;
     return await this._withElement((h, timeout) => h.screenshot({ ...options, mask, timeout }), { title: "Screenshot", timeout: options.timeout });
   }
-  async ariaSnapshot(options) {
-    const result = await this._frame._channel.ariaSnapshot({ ...options, selector: this._selector, timeout: this._frame._timeout(options) });
+  async ariaSnapshot(options = {}) {
+    const result = await this._frame._channel.ariaSnapshot({ timeout: this._frame._timeout(options), mode: options.mode, selector: this._selector, depth: options.depth });
     return result.snapshot;
   }
   async scrollIntoViewIfNeeded(options = {}) {

package/lib/client/network.js

@@ -50,8 +50,8 @@ class Request extends import_channelOwner.ChannelOwner {
     this._redirectedFrom = null;
     this._redirectedTo = null;
     this._failureText = null;
+    this._response = null;
     this._fallbackOverrides = {};
-    this._hasResponse = false;
     this._redirectedFrom = Request.fromNullable(initializer.redirectedFrom);
     if (this._redirectedFrom)
       this._redirectedFrom._redirectedTo = this;
@@ -67,8 +67,6 @@ class Request extends import_channelOwner.ChannelOwner {
       responseStart: -1,
       responseEnd: -1
     };
-    this._hasResponse = this._initializer.hasResponse;
-    this._channel.on("response", () => this._hasResponse = true);
   }
   static from(request) {
     return request._object;
@@ -142,6 +140,9 @@ class Request extends import_channelOwner.ChannelOwner {
   async _internalResponse() {
     return Response.fromNullable((await this._channel.response()).response);
   }
+  existingResponse() {
+    return this._response;
+  }
   frame() {
     if (!this._initializer.frame) {
       (0, import_assert.assert)(this.serviceWorker());
@@ -465,10 +466,9 @@ class WebSocketRouteHandler {
     const patterns = [];
     let all = false;
     for (const handler of handlers) {
-      if ((0, import_rtti.isString)(handler.url))
-        patterns.push({ glob: handler.url });
-      else if ((0, import_rtti.isRegExp)(handler.url))
-        patterns.push({ regexSource: handler.url.source, regexFlags: handler.url.flags });
+      const serialized = (0, import_urlMatch.serializeURLMatch)(handler.url);
+      if (serialized)
+        patterns.push(serialized);
       else
         all = true;
     }
@@ -491,6 +491,7 @@ class Response extends import_channelOwner.ChannelOwner {
     this._finishedPromise = new import_manualPromise.ManualPromise();
     this._provisionalHeaders = new RawHeaders(initializer.headers);
     this._request = Request.from(this._initializer.request);
+    this._request._response = this;
     Object.assign(this._request._timing, this._initializer.timing);
   }
   static from(response) {
@@ -566,6 +567,9 @@ class Response extends import_channelOwner.ChannelOwner {
   async securityDetails() {
     return (await this._channel.securityDetails()).value || null;
   }
+  async httpVersion() {
+    return (await this._channel.httpVersion()).value;
+  }
 }
 class WebSocket extends import_channelOwner.ChannelOwner {
   static from(webSocket) {
@@ -638,10 +642,9 @@ class RouteHandler {
     const patterns = [];
     let all = false;
     for (const handler of handlers) {
-      if ((0, import_rtti.isString)(handler.url))
-        patterns.push({ glob: handler.url });
-      else if ((0, import_rtti.isRegExp)(handler.url))
-        patterns.push({ regexSource: handler.url.source, regexFlags: handler.url.flags });
+      const serialized = (0, import_urlMatch.serializeURLMatch)(handler.url);
+      if (serialized)
+        patterns.push(serialized);
       else
         all = true;
     }

package/lib/client/page.js

@@ -26,6 +26,7 @@ var import_artifact = require("./artifact");
 var import_channelOwner = require("./channelOwner");
 var import_clientHelper = require("./clientHelper");
 var import_coverage = require("./coverage");
+var import_disposable = require("./disposable");
 var import_download = require("./download");
 var import_elementHandle = require("./elementHandle");
 var import_errors = require("./errors");
@@ -37,6 +38,7 @@ var import_input = require("./input");
 var import_jsHandle = require("./jsHandle");
 var import_network = require("./network");
 var import_video = require("./video");
+var import_screencast = require("./screencast");
 var import_waiter = require("./waiter");
 var import_worker = require("./worker");
 var import_timeoutSettings = require("./timeoutSettings");
@@ -58,11 +60,10 @@ class Page extends import_channelOwner.ChannelOwner {
     this._routes = [];
     this._webSocketRoutes = [];
     this._bindings = /* @__PURE__ */ new Map();
-    this._video = null;
     this._closeWasCalled = false;
     this._harRouters = [];
     this._locatorHandlers = /* @__PURE__ */ new Map();
-    this.routeInjecting = false;
+    this._instrumentation.onPage(this);
     this._browserContext = parent;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
     this.keyboard = new import_input.Keyboard(this);
@@ -76,6 +77,8 @@ class Page extends import_channelOwner.ChannelOwner {
     this._viewportSize = initializer.viewportSize;
     this._closed = initializer.isClosed;
     this._opener = Page.fromNullable(initializer.opener);
+    this._video = new import_video.Video(this, this._connection, initializer.video ? import_artifact.Artifact.from(initializer.video) : void 0);
+    this.screencast = new import_screencast.Screencast(this);
     this._channel.on("bindingCall", ({ binding }) => this._onBinding(BindingCall.from(binding)));
     this._channel.on("close", () => this._onClose());
     this._channel.on("crash", () => this._onCrash());
@@ -89,10 +92,6 @@ class Page extends import_channelOwner.ChannelOwner {
     this._channel.on("locatorHandlerTriggered", ({ uid }) => this._onLocatorHandlerTriggered(uid));
     this._channel.on("route", ({ route }) => this._onRoute(import_network.Route.from(route)));
     this._channel.on("webSocketRoute", ({ webSocketRoute }) => this._onWebSocketRoute(import_network.WebSocketRoute.from(webSocketRoute)));
-    this._channel.on("video", ({ artifact }) => {
-      const artifactObject = import_artifact.Artifact.from(artifact);
-      this._forceVideo()._artifactReady(artifactObject);
-    });
     this._channel.on("viewportSizeChanged", ({ viewportSize }) => this._viewportSize = viewportSize);
     this._channel.on("webSocket", ({ webSocket }) => this.emit(import_events.Events.Page.WebSocket, import_network.WebSocket.from(webSocket)));
     this._channel.on("worker", ({ worker }) => this._onWorker(import_worker.Worker.from(worker)));
@@ -133,7 +132,7 @@ class Page extends import_channelOwner.ChannelOwner {
     route._context = this.context();
     const routeHandlers = this._routes.slice();
     for (const routeHandler of routeHandlers) {
-      if (this._closeWasCalled || this._browserContext._closingStatus !== "none")
+      if (this._closeWasCalled || this._browserContext.isClosed())
         return;
       if (!routeHandler.matches(route.request().url()))
         continue;
@@ -210,15 +209,17 @@ class Page extends import_channelOwner.ChannelOwner {
   setDefaultTimeout(timeout) {
     this._timeoutSettings.setDefaultTimeout(timeout);
   }
-  _forceVideo() {
-    if (!this._video)
-      this._video = new import_video.Video(this, this._connection);
-    return this._video;
-  }
   video() {
     if (!this._browserContext._options.recordVideo)
       return null;
-    return this._forceVideo();
+    return this._video;
+  }
+  async pickLocator() {
+    const { selector } = await this._channel.pickLocator({});
+    return this.locator(selector);
+  }
+  async cancelPickLocator() {
+    await this._channel.cancelPickLocator({});
   }
   async $(selector, options) {
     return await this._mainFrame.$(selector, options);
@@ -229,9 +230,9 @@ class Page extends import_channelOwner.ChannelOwner {
   async dispatchEvent(selector, type, eventInit, options) {
     return await this._mainFrame.dispatchEvent(selector, type, eventInit, options);
   }
-  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    return await this._mainFrame.evaluateHandle(pageFunction, arg, isolatedContext);
+  async evaluateHandle(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    return await this._mainFrame.evaluateHandle(pageFunction, arg);
   }
   async $eval(selector, pageFunction, arg) {
     (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
@@ -251,15 +252,15 @@ class Page extends import_channelOwner.ChannelOwner {
     return await this._mainFrame.addStyleTag(options);
   }
   async exposeFunction(name, callback) {
-    await this.installInjectRoute();
-    await this._channel.exposeBinding({ name });
+    const result = await this._channel.exposeBinding({ name });
     const binding = (source, ...args) => callback(...args);
     this._bindings.set(name, binding);
+    return import_disposable.DisposableObject.from(result.disposable);
   }
   async exposeBinding(name, callback, options = {}) {
-    await this.installInjectRoute();
-    await this._channel.exposeBinding({ name, needsHandle: options.handle });
+    const result = await this._channel.exposeBinding({ name, needsHandle: options.handle });
     this._bindings.set(name, callback);
+    return import_disposable.DisposableObject.from(result.disposable);
   }
   async setExtraHTTPHeaders(headers) {
     (0, import_network.validateHeaders)(headers);
@@ -394,21 +395,18 @@ class Page extends import_channelOwner.ChannelOwner {
   viewportSize() {
     return this._viewportSize || null;
   }
-  async evaluate(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    return await this._mainFrame.evaluate(pageFunction, arg, isolatedContext);
-  }
-  async _evaluateFunction(functionDeclaration) {
-    return this._mainFrame._evaluateFunction(functionDeclaration);
+  async evaluate(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    return await this._mainFrame.evaluate(pageFunction, arg);
   }
   async addInitScript(script, arg) {
-    await this.installInjectRoute();
     const source = await (0, import_clientHelper.evaluationScript)(this._platform, script, arg);
-    await this._channel.addInitScript({ source });
+    return import_disposable.DisposableObject.from((await this._channel.addInitScript({ source })).disposable);
   }
   async route(url, handler, options = {}) {
     this._routes.unshift(new import_network.RouteHandler(this._platform, this._browserContext._options.baseURL, url, handler, options.times));
     await this._updateInterceptionPatterns({ title: "Route requests" });
+    return new import_disposable.DisposableStub(() => this.unroute(url, handler));
   }
   async routeFromHAR(har, options = {}) {
     const localUtils = this._connection.localUtils();
@@ -506,7 +504,8 @@ class Page extends import_channelOwner.ChannelOwner {
   }
   async close(options = {}) {
     this._closeReason = options.reason;
-    this._closeWasCalled = true;
+    if (!options.runBeforeUnload)
+      this._closeWasCalled = true;
     try {
       if (this._ownedContext)
         await this._ownedContext.close();
@@ -536,12 +535,18 @@ class Page extends import_channelOwner.ChannelOwner {
   async fill(selector, value, options) {
     return await this._mainFrame.fill(selector, value, options);
   }
-  async consoleMessages() {
-    const { messages } = await this._channel.consoleMessages();
+  async clearConsoleMessages() {
+    await this._channel.clearConsoleMessages();
+  }
+  async consoleMessages(options) {
+    const { messages } = await this._channel.consoleMessages({ filter: options?.filter });
     return messages.map((message) => new import_consoleMessage.ConsoleMessage(this._platform, message, this, null));
   }
-  async pageErrors() {
-    const { errors } = await this._channel.pageErrors();
+  async clearPageErrors() {
+    await this._channel.clearPageErrors();
+  }
+  async pageErrors(options) {
+    const { errors } = await this._channel.pageErrors({ filter: options?.filter });
     return errors.map((error) => (0, import_errors.parseError)(error));
   }
   locator(selector, options) {
@@ -677,23 +682,12 @@ class Page extends import_channelOwner.ChannelOwner {
     }
     return result.pdf;
   }
-  async _snapshotForAI(options = {}) {
-    return await this._channel.snapshotForAI({ timeout: this._timeoutSettings.timeout(options), track: options.track });
-  }
-  async installInjectRoute() {
-    if (this.routeInjecting || this.context().routeInjecting) return;
-    await this.route("**/*", async (route) => {
-      try {
-        if (route.request().resourceType() === "document" && route.request().url().startsWith("http")) {
-          const protocol = route.request().url().split(":")[0];
-          await route.fallback({ url: protocol + "://patchright-init-script-inject.internal/" });
-        } else {
-          await route.fallback();
-        }
-      } catch (error) {
-        await route.fallback();
-      }
-    });
+  async ariaSnapshot(options = {}) {
+    const result = await this.mainFrame()._channel.ariaSnapshot({ timeout: this._timeoutSettings.timeout(options), track: options._track, mode: options.mode, depth: options.depth });
+    return result.snapshot;
+  }
+  async _setDockTile(image) {
+    await this._channel.setDockTile({ image });
   }
 }
 class BindingCall extends import_channelOwner.ChannelOwner {

package/lib/client/screencast.js

@@ -0,0 +1,88 @@
+"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 screencast_exports = {};
+__export(screencast_exports, {
+  Screencast: () => Screencast
+});
+module.exports = __toCommonJS(screencast_exports);
+var import_artifact = require("./artifact");
+var import_disposable = require("./disposable");
+class Screencast {
+  constructor(page) {
+    this._started = false;
+    this._onFrame = null;
+    this._page = page;
+    this._page._channel.on("screencastFrame", ({ data }) => {
+      void this._onFrame?.({ data });
+    });
+  }
+  async start(options = {}) {
+    if (this._started)
+      throw new Error("Screencast is already started");
+    this._started = true;
+    if (options.onFrame)
+      this._onFrame = options.onFrame;
+    const result = await this._page._channel.screencastStart({
+      size: options.size,
+      quality: options.quality,
+      sendFrames: !!options.onFrame,
+      record: !!options.path
+    });
+    if (result.artifact) {
+      this._artifact = import_artifact.Artifact.from(result.artifact);
+      this._savePath = options.path;
+    }
+    return new import_disposable.DisposableStub(() => this.stop());
+  }
+  async stop() {
+    await this._page._wrapApiCall(async () => {
+      this._started = false;
+      this._onFrame = null;
+      await this._page._channel.screencastStop();
+      if (this._savePath)
+        await this._artifact?.saveAs(this._savePath);
+      this._artifact = void 0;
+      this._savePath = void 0;
+    });
+  }
+  async showActions(options) {
+    await this._page._channel.screencastShowActions({ duration: options?.duration, position: options?.position, fontSize: options?.fontSize });
+    return new import_disposable.DisposableStub(() => this._page._channel.screencastHideActions());
+  }
+  async hideActions() {
+    await this._page._channel.screencastHideActions();
+  }
+  async showOverlay(html, options) {
+    const { id } = await this._page._channel.screencastShowOverlay({ html, duration: options?.duration });
+    return new import_disposable.DisposableStub(() => this._page._channel.screencastRemoveOverlay({ id }));
+  }
+  async showChapter(title, options) {
+    await this._page._channel.screencastChapter({ title, ...options });
+  }
+  async showOverlays() {
+    await this._page._channel.screencastSetOverlayVisible({ visible: true });
+  }
+  async hideOverlays() {
+    await this._page._channel.screencastSetOverlayVisible({ visible: false });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Screencast
+});

package/lib/client/selectors.js

@@ -41,9 +41,11 @@ class Selectors {
   setTestIdAttribute(attributeName) {
     this._testIdAttributeName = attributeName;
     (0, import_locator.setTestIdAttribute)(attributeName);
-    for (const context of this._contextsForSelectors)
+    for (const context of this._contextsForSelectors) {
+      context._options.testIdAttributeName = attributeName;
       context._channel.setTestIdAttributeName({ testIdAttributeName: attributeName }).catch(() => {
       });
+    }
   }
   _withSelectorOptions(options) {
     return { ...options, selectorEngines: this._selectorEngines, testIdAttributeName: this._testIdAttributeName };

package/lib/client/tracing.js

@@ -23,10 +23,12 @@ __export(tracing_exports, {
 module.exports = __toCommonJS(tracing_exports);
 var import_artifact = require("./artifact");
 var import_channelOwner = require("./channelOwner");
+var import_disposable = require("./disposable");
 class Tracing extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
     this._includeSources = false;
+    this._additionalSources = /* @__PURE__ */ new Set();
     this._isLive = false;
     this._isTracing = false;
   }
@@ -34,15 +36,14 @@ class Tracing extends import_channelOwner.ChannelOwner {
     return channel._object;
   }
   async start(options = {}) {
-    await this._parent.installInjectRoute();
     await this._wrapApiCall(async () => {
       this._includeSources = !!options.sources;
-      this._isLive = !!options._live;
+      this._isLive = !!options.live;
       await this._channel.tracingStart({
         name: options.name,
         snapshots: options.snapshots,
         screenshots: options.screenshots,
-        live: options._live
+        live: options.live
       });
       const { traceName } = await this._channel.tracingStartChunk({ name: options.name, title: options.title });
       await this._startCollectingStacks(traceName, this._isLive);
@@ -55,7 +56,10 @@ class Tracing extends import_channelOwner.ChannelOwner {
     });
   }
   async group(name, options = {}) {
+    if (options.location)
+      this._additionalSources.add(options.location.file);
     await this._channel.tracingGroup({ name, location: options.location });
+    return new import_disposable.DisposableStub(() => this.groupEnd());
   }
   async groupEnd() {
     await this._channel.tracingGroupEnd();
@@ -81,6 +85,8 @@ class Tracing extends import_channelOwner.ChannelOwner {
   }
   async _doStopChunk(filePath) {
     this._resetStackCounter();
+    const additionalSources = [...this._additionalSources];
+    this._additionalSources.clear();
     if (!filePath) {
       await this._channel.tracingStopChunk({ mode: "discard" });
       if (this._stacksId)
@@ -93,7 +99,7 @@ class Tracing extends import_channelOwner.ChannelOwner {
     const isLocal = !this._connection.isRemote();
     if (isLocal) {
       const result2 = await this._channel.tracingStopChunk({ mode: "entries" });
-      await localUtils.zip({ zipFile: filePath, entries: result2.entries, mode: "write", stacksId: this._stacksId, includeSources: this._includeSources });
+      await localUtils.zip({ zipFile: filePath, entries: result2.entries, mode: "write", stacksId: this._stacksId, includeSources: this._includeSources, additionalSources });
       return;
     }
     const result = await this._channel.tracingStopChunk({ mode: "archive" });
@@ -105,7 +111,7 @@ class Tracing extends import_channelOwner.ChannelOwner {
     const artifact = import_artifact.Artifact.from(result.artifact);
     await artifact.saveAs(filePath);
     await artifact.delete();
-    await localUtils.zip({ zipFile: filePath, entries: [], mode: "append", stacksId: this._stacksId, includeSources: this._includeSources });
+    await localUtils.zip({ zipFile: filePath, entries: [], mode: "append", stacksId: this._stacksId, includeSources: this._includeSources, additionalSources });
   }
   _resetStackCounter() {
     if (this._isTracing) {

package/lib/client/video.js

@@ -21,36 +21,29 @@ __export(video_exports, {
   Video: () => Video
 });
 module.exports = __toCommonJS(video_exports);
-var import_manualPromise = require("../utils/isomorphic/manualPromise");
-class Video {
-  constructor(page, connection) {
-    this._artifact = null;
-    this._artifactReadyPromise = new import_manualPromise.ManualPromise();
+var import_eventEmitter = require("./eventEmitter");
+class Video extends import_eventEmitter.EventEmitter {
+  constructor(page, connection, artifact) {
+    super(page._platform);
     this._isRemote = false;
     this._isRemote = connection.isRemote();
-    this._artifact = page._closedOrCrashedScope.safeRace(this._artifactReadyPromise);
-  }
-  _artifactReady(artifact) {
-    this._artifactReadyPromise.resolve(artifact);
+    this._artifact = artifact;
   }
   async path() {
     if (this._isRemote)
       throw new Error(`Path is not available when connecting remotely. Use saveAs() to save a local copy.`);
-    const artifact = await this._artifact;
-    if (!artifact)
-      throw new Error("Page did not produce any video frames");
-    return artifact._initializer.absolutePath;
+    if (!this._artifact)
+      throw new Error("Video recording has not been started.");
+    return this._artifact._initializer.absolutePath;
   }
   async saveAs(path) {
-    const artifact = await this._artifact;
-    if (!artifact)
-      throw new Error("Page did not produce any video frames");
-    return await artifact.saveAs(path);
+    if (!this._artifact)
+      throw new Error("Video recording has not been started.");
+    return await this._artifact.saveAs(path);
   }
   async delete() {
-    const artifact = await this._artifact;
-    if (artifact)
-      await artifact.delete();
+    if (this._artifact)
+      await this._artifact.delete();
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/lib/client/worker.js

@@ -54,14 +54,14 @@ class Worker extends import_channelOwner.ChannelOwner {
   url() {
     return this._initializer.url;
   }
-  async evaluate(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
+  async evaluate(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpression({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async evaluateHandle(pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
-    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
+  async evaluateHandle(pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 2);
+    const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return import_jsHandle.JSHandle.from(result.handle);
   }
   async waitForEvent(event, optionsOrPredicate = {}) {