patchright-core 1.58.2 → 1.59.0

package/lib/client/frame.js

@@ -101,7 +101,6 @@ class Frame extends import_channelOwner.ChannelOwner {
   }
   async goto(url, options = {}) {
     const waitUntil = verifyLoadState("waitUntil", options.waitUntil === void 0 ? "load" : options.waitUntil);
-    this.page().context()._checkUrlAllowed(url);
     return network.Response.fromNullable((await this._channel.goto({ url, ...options, waitUntil, timeout: this._navigationTimeout(options) })).response);
   }
   _setupNavigationWaiter(options) {
@@ -162,31 +161,19 @@ class Frame extends import_channelOwner.ChannelOwner {
   async waitForURL(url, options = {}) {
     if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url))
       return await this.waitForLoadState(options.waitUntil, options);
-    try {
-      await this.waitForNavigation({ url, ...options });
-    } catch (error) {
-      if ((0, import_urlMatch.urlMatches)(this._page?.context()._options.baseURL, this.url(), url)) {
-        await this.waitForLoadState(options.waitUntil, options);
-        return;
-      }
-      throw error;
-    }
+    await this.waitForNavigation({ url, ...options });
   }
   async frameElement() {
     return import_elementHandle.ElementHandle.from((await this._channel.frameElement()).element);
   }
-  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 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 });
-    return (0, import_jsHandle.parseResult)(result.value);
-  }
-  async _evaluateFunction(functionDeclaration) {
-    const result = await this._channel.evaluateExpression({ expression: functionDeclaration, isFunction: true, arg: (0, import_jsHandle.serializeArgument)(void 0) });
+  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 _evaluateExposeUtilityScript(pageFunction, arg) {
@@ -214,9 +201,9 @@ class Frame extends import_channelOwner.ChannelOwner {
     const result = await this._channel.evalOnSelector({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
-  async $$eval(selector, pageFunction, arg, isolatedContext = true) {
-    (0, import_jsHandle.assertMaxArguments)(arguments.length, 4);
-    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg), isolatedContext });
+  async $$eval(selector, pageFunction, arg) {
+    (0, import_jsHandle.assertMaxArguments)(arguments.length, 3);
+    const result = await this._channel.evalOnSelectorAll({ selector, expression: String(pageFunction), isFunction: typeof pageFunction === "function", arg: (0, import_jsHandle.serializeArgument)(arg) });
     return (0, import_jsHandle.parseResult)(result.value);
   }
   async $$(selector) {

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,45 +97,14 @@ class Locator {
       ...options
     });
   }
-  async evaluate(pageFunction, arg, options, isolatedContext = true) {
-    if (typeof options === "boolean") {
-      isolatedContext = options;
-      options = void 0;
-    }
-    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) {
-    if (typeof options === "boolean") {
-      isolatedContext = options;
-      options = void 0;
-    }
-    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 });
@@ -228,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 });
@@ -271,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;
@@ -128,11 +126,7 @@ class Request extends import_channelOwner.ChannelOwner {
     return await this._actualHeadersPromise;
   }
   async allHeaders() {
-    const headers = await this._actualHeaders();
-    const page = this._safePage();
-    if (page?._closeWasCalled)
-      throw new import_errors.TargetClosedError();
-    return headers.headers();
+    return (await this._actualHeaders()).headers();
   }
   async headersArray() {
     return (await this._actualHeaders()).headersArray();
@@ -146,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());
@@ -469,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;
     }
@@ -495,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) {
@@ -570,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) {
@@ -642,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");
@@ -48,7 +50,6 @@ var import_urlMatch = require("../utils/isomorphic/urlMatch");
 var import_manualPromise = require("../utils/isomorphic/manualPromise");
 var import_rtti = require("../utils/isomorphic/rtti");
 var import_consoleMessage = require("./consoleMessage");
-var import_pageAgent = require("./pageAgent");
 class Page extends import_channelOwner.ChannelOwner {
   constructor(parent, type, guid, initializer) {
     super(parent, type, guid, initializer);
@@ -59,11 +60,9 @@ 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);
@@ -78,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());
@@ -91,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)));
@@ -135,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;
@@ -212,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);
@@ -231,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);
@@ -253,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);
@@ -396,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();
@@ -539,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) {
@@ -680,48 +682,12 @@ class Page extends import_channelOwner.ChannelOwner {
     }
     return result.pdf;
   }
-  // @ts-expect-error agents are hidden
-  async agent(options = {}) {
-    const params = {
-      api: options.provider?.api,
-      apiEndpoint: options.provider?.apiEndpoint,
-      apiKey: options.provider?.apiKey,
-      apiTimeout: options.provider?.apiTimeout,
-      apiCacheFile: options.provider?._apiCacheFile,
-      doNotRenderActive: options._doNotRenderActive,
-      model: options.provider?.model,
-      cacheFile: options.cache?.cacheFile,
-      cacheOutFile: options.cache?.cacheOutFile,
-      maxTokens: options.limits?.maxTokens,
-      maxActions: options.limits?.maxActions,
-      maxActionRetries: options.limits?.maxActionRetries,
-      // @ts-expect-error runAgents is hidden
-      secrets: options.secrets ? Object.entries(options.secrets).map(([name, value]) => ({ name, value })) : void 0,
-      systemPrompt: options.systemPrompt
-    };
-    const { agent } = await this._channel.agent(params);
-    const pageAgent = import_pageAgent.PageAgent.from(agent);
-    pageAgent._expectTimeout = options?.expect?.timeout;
-    return pageAgent;
-  }
-  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();
-      }
-    });
-    this.routeInjecting = true;
+  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/platform.js

@@ -66,9 +66,6 @@ const emptyPlatform = {
   streamWritable: (channel) => {
     throw new Error("Streams are not available");
   },
-  zodToJsonSchema: (schema) => {
-    throw new Error("Zod is not available");
-  },
   zones: { empty: noopZone, current: () => noopZone }
 };
 // Annotate the CommonJS export names for ESM import in node:

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 };