patchright-core 1.52.5 → 1.55.1

package/lib/client/browserContext.js

@@ -34,7 +34,6 @@ __export(browserContext_exports, {
 });
 module.exports = __toCommonJS(browserContext_exports);
 var import_artifact = require("./artifact");
-var import_browser = require("./browser");
 var import_cdpSession = require("./cdpSession");
 var import_channelOwner = require("./channelOwner");
 var import_clientHelper = require("./clientHelper");
@@ -64,22 +63,21 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._pages = /* @__PURE__ */ new Set();
     this._routes = [];
     this._webSocketRoutes = [];
+    // Browser is null for browser contexts created outside of normal browser, e.g. android or electron.
     this._browser = null;
     this._bindings = /* @__PURE__ */ new Map();
-    this._options = {};
+    this._forReuse = false;
     this._backgroundPages = /* @__PURE__ */ new Set();
     this._serviceWorkers = /* @__PURE__ */ new Set();
     this._harRecorders = /* @__PURE__ */ new Map();
-    this._closeWasCalled = false;
+    this._closingStatus = "none";
     this._harRouters = [];
     this.routeInjecting = false;
+    this._options = initializer.options;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform);
-    if (parent instanceof import_browser.Browser)
-      this._browser = parent;
-    this._browser?._contexts.add(this);
-    this._isChromium = this._browser?._name === "chromium";
     this.tracing = import_tracing.Tracing.from(initializer.tracing);
     this.request = import_fetch.APIRequestContext.from(initializer.requestContext);
+    this.request._timeoutSettings = this._timeoutSettings;
     this.clock = new import_clock.Clock(this);
     this._channel.on("bindingCall", ({ binding }) => this._onBinding(import_page.BindingCall.from(binding)));
     this._channel.on("close", () => this._onClose());
@@ -130,6 +128,14 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     this._channel.on("requestFailed", ({ request, failureText, responseEndTiming, page }) => this._onRequestFailed(network.Request.from(request), responseEndTiming, failureText, import_page.Page.fromNullable(page)));
     this._channel.on("requestFinished", (params) => this._onRequestFinished(params));
     this._channel.on("response", ({ response, page }) => this._onResponse(network.Response.from(response), import_page.Page.fromNullable(page)));
+    this._channel.on("recorderEvent", ({ event, data, page, code }) => {
+      if (event === "actionAdded")
+        this._onRecorderEventSink?.actionAdded?.(import_page.Page.from(page), data, code);
+      else if (event === "actionUpdated")
+        this._onRecorderEventSink?.actionUpdated?.(import_page.Page.from(page), data, code);
+      else if (event === "signalAdded")
+        this._onRecorderEventSink?.signalAdded?.(import_page.Page.from(page), data);
+    });
     this._closedPromise = new Promise((f) => this.once(import_events.Events.BrowserContext.Close, f));
     this._setEventToSubscriptionMapping(/* @__PURE__ */ new Map([
       [import_events.Events.BrowserContext.Console, "console"],
@@ -146,11 +152,15 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   static fromNullable(context) {
     return context ? BrowserContext.from(context) : null;
   }
-  _setOptions(contextOptions, browserOptions) {
-    this._options = contextOptions;
-    if (this._options.recordHar)
-      this._harRecorders.set("", { path: this._options.recordHar.path, content: this._options.recordHar.content });
-    this.tracing._tracesDir = browserOptions.tracesDir;
+  async _initializeHarFromOptions(recordHar) {
+    if (!recordHar)
+      return;
+    const defaultContent = recordHar.path.endsWith(".zip") ? "attach" : "embed";
+    await this._recordIntoHAR(recordHar.path, null, {
+      url: recordHar.urlFilter,
+      updateContent: recordHar.content ?? (recordHar.omitContent ? "omit" : defaultContent),
+      updateMode: recordHar.mode ?? "full"
+    });
   }
   _onPage(page) {
     this._pages.add(page);
@@ -192,7 +202,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     const page = route.request()._safePage();
     const routeHandlers = this._routes.slice();
     for (const routeHandler of routeHandlers) {
-      if (page?._closeWasCalled || this._closeWasCalled)
+      if (page?._closeWasCalled || this._closingStatus !== "none")
         return;
       if (!routeHandler.matches(route.request().url()))
         continue;
@@ -203,7 +213,7 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         this._routes.splice(index, 1);
       const handled = await routeHandler.handle(route);
       if (!this._routes.length)
-        this._wrapApiCall(() => this._updateInterceptionPatterns(), true).catch(() => {
+        this._updateInterceptionPatterns({ internal: true }).catch(() => {
         });
       if (handled)
         return;
@@ -229,17 +239,9 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   }
   setDefaultNavigationTimeout(timeout) {
     this._timeoutSettings.setDefaultNavigationTimeout(timeout);
-    this._wrapApiCall(async () => {
-      await this._channel.setDefaultNavigationTimeoutNoReply({ timeout });
-    }, true).catch(() => {
-    });
   }
   setDefaultTimeout(timeout) {
     this._timeoutSettings.setDefaultTimeout(timeout);
-    this._wrapApiCall(async () => {
-      await this._channel.setDefaultTimeoutNoReply({ timeout });
-    }, true).catch(() => {
-    });
   }
   browser() {
     return this._browser;
@@ -312,21 +314,23 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   }
   async route(url, handler, options = {}) {
     this._routes.unshift(new network.RouteHandler(this._platform, this._options.baseURL, url, handler, options.times));
-    await this._updateInterceptionPatterns();
+    await this._updateInterceptionPatterns({ title: "Route requests" });
   }
   async routeWebSocket(url, handler) {
     this._webSocketRoutes.unshift(new network.WebSocketRouteHandler(this._options.baseURL, url, handler));
-    await this._updateWebSocketInterceptionPatterns();
+    await this._updateWebSocketInterceptionPatterns({ title: "Route WebSockets" });
   }
   async _recordIntoHAR(har, page, options = {}) {
     const { harId } = await this._channel.harStart({
       page: page?._channel,
-      options: prepareRecordHarOptions({
-        path: har,
+      options: {
+        zip: har.endsWith(".zip"),
         content: options.updateContent ?? "attach",
-        mode: options.updateMode ?? "minimal",
-        urlFilter: options.url
-      })
+        urlGlob: (0, import_rtti.isString)(options.url) ? options.url : void 0,
+        urlRegexSource: (0, import_rtti.isRegExp)(options.url) ? options.url.source : void 0,
+        urlRegexFlags: (0, import_rtti.isRegExp)(options.url) ? options.url.flags : void 0,
+        mode: options.updateMode ?? "minimal"
+      }
     });
     this._harRecorders.set(harId, { path: har, content: options.updateContent ?? "attach" });
   }
@@ -363,19 +367,19 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
   }
   async _unrouteInternal(removed, remaining, behavior) {
     this._routes = remaining;
-    await this._updateInterceptionPatterns();
-    if (!behavior || behavior === "default")
-      return;
-    const promises = removed.map((routeHandler) => routeHandler.stop(behavior));
-    await Promise.all(promises);
+    if (behavior && behavior !== "default") {
+      const promises = removed.map((routeHandler) => routeHandler.stop(behavior));
+      await Promise.all(promises);
+    }
+    await this._updateInterceptionPatterns({ title: "Unroute requests" });
   }
-  async _updateInterceptionPatterns() {
+  async _updateInterceptionPatterns(options) {
     const patterns = network.RouteHandler.prepareInterceptionPatterns(this._routes);
-    await this._channel.setNetworkInterceptionPatterns({ patterns });
+    await this._wrapApiCall(() => this._channel.setNetworkInterceptionPatterns({ patterns }), options);
   }
-  async _updateWebSocketInterceptionPatterns() {
+  async _updateWebSocketInterceptionPatterns(options) {
     const patterns = network.WebSocketRouteHandler.prepareInterceptionPatterns(this._webSocketRoutes);
-    await this._channel.setWebSocketInterceptionPatterns({ patterns });
+    await this._wrapApiCall(() => this._channel.setWebSocketInterceptionPatterns({ patterns }), options);
   }
   _effectiveCloseReason() {
     return this._closeReason || this._browser?._closeReason;
@@ -414,9 +418,10 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     return import_cdpSession.CDPSession.from(result.session);
   }
   _onClose() {
-    if (this._browser)
-      this._browser._contexts.delete(this);
-    this._browserType?._contexts?.delete(this);
+    this._closingStatus = "closed";
+    this._browser?._contexts.delete(this);
+    this._browser?._browserType._contexts.delete(this);
+    this._browser?._browserType._playwright.selectors._contextsForSelectors.delete(this);
     this._disposeHarRouters();
     this.tracing._resetStackCounter();
     this.emit(import_events.Events.BrowserContext.Close, this);
@@ -425,15 +430,13 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
     await this.close();
   }
   async close(options = {}) {
-    if (this._closeWasCalled)
+    if (this._closingStatus !== "none")
       return;
     this._closeReason = options.reason;
-    this._closeWasCalled = true;
-    await this._wrapApiCall(async () => {
-      await this.request.dispose(options);
-    }, true);
+    this._closingStatus = "closing";
+    await this.request.dispose(options);
+    await this._instrumentation.runBeforeCloseBrowserContext(this);
     await this._wrapApiCall(async () => {
-      await this._browserType?._willCloseContext(this);
       for (const [harId, harParams] of this._harRecorders) {
         const har = await this._channel.harExport({ harId });
         const artifact = import_artifact.Artifact.from(har.artifact);
@@ -450,52 +453,46 @@ class BrowserContext extends import_channelOwner.ChannelOwner {
         }
         await artifact.delete();
       }
-    }, true);
+    }, { internal: true });
     await this._channel.close(options);
     await this._closedPromise;
   }
-  async _enableRecorder(params) {
+  async _enableRecorder(params, eventSink) {
+    if (eventSink)
+      this._onRecorderEventSink = eventSink;
     await this._channel.enableRecorder(params);
   }
+  async _disableRecorder() {
+    this._onRecorderEventSink = void 0;
+    await this._channel.disableRecorder();
+  }
   async installInjectRoute() {
     if (this.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.continue({ url: protocol + "://patchright-init-script-inject.internal/" });
+          await route.fallback({ url: protocol + "://patchright-init-script-inject.internal/" });
         } else {
-          await route.continue();
+          await route.fallback();
         }
       } catch (error) {
-        await route.continue();
+        await route.fallback();
       }
     });
   }
 }
-async function prepareStorageState(platform, options) {
-  if (typeof options.storageState !== "string")
-    return options.storageState;
+async function prepareStorageState(platform, storageState) {
+  if (typeof storageState !== "string")
+    return storageState;
   try {
-    return JSON.parse(await platform.fs().promises.readFile(options.storageState, "utf8"));
+    return JSON.parse(await platform.fs().promises.readFile(storageState, "utf8"));
   } catch (e) {
-    (0, import_stackTrace.rewriteErrorMessage)(e, `Error reading storage state from ${options.storageState}:
+    (0, import_stackTrace.rewriteErrorMessage)(e, `Error reading storage state from ${storageState}:
 ` + e.message);
     throw e;
   }
 }
-function prepareRecordHarOptions(options) {
-  if (!options)
-    return;
-  return {
-    path: options.path,
-    content: options.content || (options.omitContent ? "omit" : void 0),
-    urlGlob: (0, import_rtti.isString)(options.urlFilter) ? options.urlFilter : void 0,
-    urlRegexSource: (0, import_rtti.isRegExp)(options.urlFilter) ? options.urlFilter.source : void 0,
-    urlRegexFlags: (0, import_rtti.isRegExp)(options.urlFilter) ? options.urlFilter.flags : void 0,
-    mode: options.mode
-  };
-}
 async function prepareBrowserContextParams(platform, options) {
   if (options.videoSize && !options.videosPath)
     throw new Error(`"videoSize" option requires "videosPath" to be specified`);
@@ -506,9 +503,8 @@ async function prepareBrowserContextParams(platform, options) {
     viewport: options.viewport === null ? void 0 : options.viewport,
     noDefaultViewport: options.viewport === null,
     extraHTTPHeaders: options.extraHTTPHeaders ? (0, import_headers.headersObjectToArray)(options.extraHTTPHeaders) : void 0,
-    storageState: await prepareStorageState(platform, options),
+    storageState: options.storageState ? await prepareStorageState(platform, options.storageState) : void 0,
     serviceWorkers: options.serviceWorkers,
-    recordHar: prepareRecordHarOptions(options.recordHar),
     colorScheme: options.colorScheme === null ? "no-override" : options.colorScheme,
     reducedMotion: options.reducedMotion === null ? "no-override" : options.reducedMotion,
     forcedColors: options.forcedColors === null ? "no-override" : options.forcedColors,

package/lib/client/browserType.js

@@ -31,6 +31,7 @@ var import_headers = require("../utils/isomorphic/headers");
 var import_time = require("../utils/isomorphic/time");
 var import_timeoutRunner = require("../utils/isomorphic/timeoutRunner");
 var import_webSocket = require("./webSocket");
+var import_timeoutSettings = require("./timeoutSettings");
 class BrowserType extends import_channelOwner.ChannelOwner {
   constructor() {
     super(...arguments);
@@ -56,11 +57,12 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       ...options,
       ignoreDefaultArgs: Array.isArray(options.ignoreDefaultArgs) ? options.ignoreDefaultArgs : void 0,
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
-      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0
+      env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
     };
     return await this._wrapApiCall(async () => {
       const browser = import_browser.Browser.from((await this._channel.launch(launchOptions)).browser);
-      this._didLaunchBrowser(browser, options, logger);
+      browser._connectToBrowserType(this, options, logger);
       return browser;
     });
   }
@@ -73,7 +75,11 @@ class BrowserType extends import_channelOwner.ChannelOwner {
   async launchPersistentContext(userDataDir, options = {}) {
     const logger = options.logger || this._playwright._defaultLaunchOptions?.logger;
     (0, import_assert.assert)(!options.port, "Cannot specify a port without launching as a server.");
-    options = { ...this._playwright._defaultLaunchOptions, ...this._playwright._defaultContextOptions, ...options };
+    options = this._playwright.selectors._withSelectorOptions({
+      ...this._playwright._defaultLaunchOptions,
+      ...this._playwright._defaultContextOptions,
+      ...options
+    });
     const contextParams = await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options);
     const persistentParams = {
       ...contextParams,
@@ -81,14 +87,19 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       ignoreAllDefaultArgs: !!options.ignoreDefaultArgs && !Array.isArray(options.ignoreDefaultArgs),
       env: options.env ? (0, import_clientHelper.envObjectToArray)(options.env) : void 0,
       channel: options.channel,
-      userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir)
+      userDataDir: this._platform.path().isAbsolute(userDataDir) || !userDataDir ? userDataDir : this._platform.path().resolve(userDataDir),
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
     };
-    return await this._wrapApiCall(async () => {
+    const context = await this._wrapApiCall(async () => {
       const result = await this._channel.launchPersistentContext(persistentParams);
-      const context = import_browserContext.BrowserContext.from(result.context);
-      await this._didCreateContext(context, contextParams, options, logger);
-      return context;
+      const browser = import_browser.Browser.from(result.browser);
+      browser._connectToBrowserType(this, options, logger);
+      const context2 = import_browserContext.BrowserContext.from(result.context);
+      await context2._initializeHarFromOptions(options.recordHar);
+      return context2;
     });
+    await this._instrumentation.runAfterCreateBrowserContext(context);
+    return context;
   }
   async connect(optionsOrWsEndpoint, options) {
     if (typeof optionsOrWsEndpoint === "string")
@@ -106,7 +117,7 @@ class BrowserType extends import_channelOwner.ChannelOwner {
         headers,
         exposeNetwork: params.exposeNetwork ?? params._exposeNetwork,
         slowMo: params.slowMo,
-        timeout: params.timeout
+        timeout: params.timeout || 0
       };
       if (params.__testHookRedirectPortForwarding)
         connectParams.socksProxyRedirectPortForTest = params.__testHookRedirectPortForwarding;
@@ -128,9 +139,9 @@ class BrowserType extends import_channelOwner.ChannelOwner {
           connection.close();
           throw new Error("Malformed endpoint. Did you use BrowserType.launchServer method?");
         }
-        playwright._setSelectors(this._playwright.selectors);
+        playwright.selectors = this._playwright.selectors;
         browser = import_browser.Browser.from(playwright._initializer.preLaunchedBrowser);
-        this._didLaunchBrowser(browser, {}, logger);
+        browser._connectToBrowserType(this, {}, logger);
         browser._shouldCloseConnectionOnClose = true;
         browser.on(import_events.Events.Browser.Disconnected, () => connection.close());
         return browser;
@@ -158,34 +169,14 @@ class BrowserType extends import_channelOwner.ChannelOwner {
       endpointURL,
       headers,
       slowMo: params.slowMo,
-      timeout: params.timeout
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).timeout(params)
     });
     const browser = import_browser.Browser.from(result.browser);
-    this._didLaunchBrowser(browser, {}, params.logger);
+    browser._connectToBrowserType(this, {}, params.logger);
     if (result.defaultContext)
-      await this._didCreateContext(import_browserContext.BrowserContext.from(result.defaultContext), {}, {}, params.logger);
+      await this._instrumentation.runAfterCreateBrowserContext(import_browserContext.BrowserContext.from(result.defaultContext));
     return browser;
   }
-  _didLaunchBrowser(browser, browserOptions, logger) {
-    browser._browserType = this;
-    browser._options = browserOptions;
-    browser._logger = logger;
-  }
-  async _didCreateContext(context, contextOptions, browserOptions, logger) {
-    context._logger = logger;
-    context._browserType = this;
-    this._contexts.add(context);
-    context._setOptions(contextOptions, browserOptions);
-    if (this._playwright._defaultContextTimeout !== void 0)
-      context.setDefaultTimeout(this._playwright._defaultContextTimeout);
-    if (this._playwright._defaultContextNavigationTimeout !== void 0)
-      context.setDefaultNavigationTimeout(this._playwright._defaultContextNavigationTimeout);
-    await this._instrumentation.runAfterCreateBrowserContext(context);
-  }
-  async _willCloseContext(context) {
-    this._contexts.delete(context);
-    await this._instrumentation.runBeforeCloseBrowserContext(context);
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/client/channelOwner.js

@@ -23,6 +23,7 @@ __export(channelOwner_exports, {
 module.exports = __toCommonJS(channelOwner_exports);
 var import_eventEmitter = require("./eventEmitter");
 var import_validator = require("../protocol/validator");
+var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
 var import_clientStackTrace = require("./clientStackTrace");
 var import_stackTrace = require("../utils/isomorphic/stackTrace");
 class ChannelOwner extends import_eventEmitter.EventEmitter {
@@ -31,7 +32,6 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
     super(connection._platform);
     this._objects = /* @__PURE__ */ new Map();
     this._eventToSubscriptionMapping = /* @__PURE__ */ new Map();
-    this._isInternalType = false;
     this._wasCollected = false;
     this.setMaxListeners(0);
     this._connection = connection;
@@ -47,20 +47,14 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
     this._channel = this._createChannel(new import_eventEmitter.EventEmitter(connection._platform));
     this._initializer = initializer;
   }
-  markAsInternalType() {
-    this._isInternalType = true;
-  }
   _setEventToSubscriptionMapping(mapping) {
     this._eventToSubscriptionMapping = mapping;
   }
   _updateSubscription(event, enabled) {
     const protocolEvent = this._eventToSubscriptionMapping.get(String(event));
-    if (protocolEvent) {
-      this._wrapApiCall(async () => {
-        await this._channel.updateSubscription({ event: protocolEvent, enabled });
-      }, true).catch(() => {
+    if (protocolEvent)
+      this._channel.updateSubscription({ event: protocolEvent, enabled }).catch(() => {
       });
-    }
   }
   on(event, listener) {
     if (!this.listenerCount(event))
@@ -124,19 +118,19 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
       get: (obj, prop) => {
         if (typeof prop === "string") {
           const validator = (0, import_validator.maybeFindValidator)(this._type, prop, "Params");
+          const { internal } = import_protocolMetainfo.methodMetainfo.get(this._type + "." + prop) || {};
           if (validator) {
             return async (params) => {
               return await this._wrapApiCall(async (apiZone) => {
                 const validatedParams = validator(params, "", this._validatorToWireContext());
-                if (!apiZone.isInternal && !apiZone.reported) {
-                  apiZone.params = params;
+                if (!apiZone.internal && !apiZone.reported) {
                   apiZone.reported = true;
-                  this._instrumentation.onApiCallBegin(apiZone);
+                  this._instrumentation.onApiCallBegin(apiZone, { type: this._type, method: prop, params });
                   logApiCall(this._platform, this._logger, `=> ${apiZone.apiName} started`);
-                  return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone.apiName, apiZone.frames, apiZone.stepId);
+                  return await this._connection.sendMessageToServer(this, prop, validatedParams, apiZone);
                 }
-                return await this._connection.sendMessageToServer(this, prop, validatedParams, void 0, [], void 0);
-              });
+                return await this._connection.sendMessageToServer(this, prop, validatedParams, { internal: true });
+              }, { internal });
             };
           }
         }
@@ -146,18 +140,16 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
     channel._object = this;
     return channel;
   }
-  async _wrapApiCall(func, isInternal) {
+  async _wrapApiCall(func, options) {
     const logger = this._logger;
     const existingApiZone = this._platform.zones.current().data();
     if (existingApiZone)
       return await func(existingApiZone);
-    if (isInternal === void 0)
-      isInternal = this._isInternalType;
     const stackTrace = (0, import_clientStackTrace.captureLibraryStackTrace)(this._platform);
-    const apiZone = { apiName: stackTrace.apiName, frames: stackTrace.frames, isInternal, reported: false, userData: void 0, stepId: void 0 };
+    const apiZone = { title: options?.title, apiName: stackTrace.apiName, frames: stackTrace.frames, internal: options?.internal ?? false, reported: false, userData: void 0, stepId: void 0 };
     try {
       const result = await this._platform.zones.current().push(apiZone).run(async () => await func(apiZone));
-      if (!isInternal) {
+      if (!options?.internal) {
         logApiCall(this._platform, logger, `<= ${apiZone.apiName} succeeded`);
         this._instrumentation.onApiCallEnd(apiZone);
       }
@@ -171,17 +163,21 @@ class ChannelOwner extends import_eventEmitter.EventEmitter {
         e.stack = e.message + stackFrames;
       else
         e.stack = "";
-      if (!isInternal) {
+      if (!options?.internal) {
+        const recoveryHandlers = [];
         apiZone.error = e;
+        this._instrumentation.onApiCallRecovery(apiZone, e, recoveryHandlers);
+        for (const handler of recoveryHandlers) {
+          const recoverResult = await handler();
+          if (recoverResult.status === "recovered")
+            return recoverResult.value;
+        }
         logApiCall(this._platform, logger, `<= ${apiZone.apiName} failed`);
         this._instrumentation.onApiCallEnd(apiZone);
       }
       throw e;
     }
   }
-  _toImpl() {
-    return this._connection.toImpl?.(this);
-  }
   toJSON() {
     return {
       _type: this._type,

package/lib/client/connection.js

@@ -42,7 +42,6 @@ var import_localUtils = require("./localUtils");
 var import_network = require("./network");
 var import_page = require("./page");
 var import_playwright = require("./playwright");
-var import_selectors = require("./selectors");
 var import_stream = require("./stream");
 var import_tracing = require("./tracing");
 var import_worker = require("./worker");
@@ -104,7 +103,7 @@ class Connection extends import_eventEmitter.EventEmitter {
     else
       this._tracingCount--;
   }
-  async sendMessageToServer(object, method, params, apiName, frames, stepId) {
+  async sendMessageToServer(object, method, params, options) {
     if (this._closedError)
       throw this._closedError;
     if (object._wasCollected)
@@ -116,13 +115,13 @@ class Connection extends import_eventEmitter.EventEmitter {
     if (this._platform.isLogEnabled("channel")) {
       this._platform.log("channel", "SEND> " + JSON.stringify(message));
     }
-    const location = frames[0] ? { file: frames[0].file, line: frames[0].line, column: frames[0].column } : void 0;
-    const metadata = { apiName, location, internal: !apiName, stepId };
-    if (this._tracingCount && frames && type !== "LocalUtils")
-      this._localUtils?.addStackToTracingNoReply({ callData: { stack: frames, id } }).catch(() => {
+    const location = options.frames?.[0] ? { file: options.frames[0].file, line: options.frames[0].line, column: options.frames[0].column } : void 0;
+    const metadata = { title: options.title, location, internal: options.internal, stepId: options.stepId };
+    if (this._tracingCount && options.frames && type !== "LocalUtils")
+      this._localUtils?.addStackToTracingNoReply({ callData: { stack: options.frames ?? [], id } }).catch(() => {
       });
     this._platform.zones.empty.run(() => this.onmessage({ ...message, metadata }));
-    return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, apiName, type, method }));
+    return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject, title: options.title, type, method }));
   }
   _validatorFromWireContext() {
     return {
@@ -277,9 +276,6 @@ class Connection extends import_eventEmitter.EventEmitter {
       case "Stream":
         result = new import_stream.Stream(parent, type, guid, initializer);
         break;
-      case "Selectors":
-        result = new import_selectors.SelectorsOwner(parent, type, guid, initializer);
-        break;
       case "SocksSupport":
         result = new DummyChannelOwner(parent, type, guid, initializer);
         break;

package/lib/client/electron.js

@@ -39,13 +39,18 @@ class Electron extends import_channelOwner.ChannelOwner {
     super(parent, type, guid, initializer);
   }
   async launch(options = {}) {
+    options = this._playwright.selectors._withSelectorOptions(options);
     const params = {
       ...await (0, import_browserContext.prepareBrowserContextParams)(this._platform, options),
       env: (0, import_clientHelper.envObjectToArray)(options.env ? options.env : this._platform.env),
-      tracesDir: options.tracesDir
+      tracesDir: options.tracesDir,
+      timeout: new import_timeoutSettings.TimeoutSettings(this._platform).launchTimeout(options)
     };
     const app = ElectronApplication.from((await this._channel.launch(params)).electronApplication);
-    app._context._setOptions(params, options);
+    this._playwright.selectors._contextsForSelectors.add(app._context);
+    app.once(import_events.Events.ElectronApplication.Close, () => this._playwright.selectors._contextsForSelectors.delete(app._context));
+    await app._context._initializeHarFromOptions(options.recordHar);
+    app._context.tracing._tracesDir = options.tracesDir;
     return app;
   }
 }
@@ -70,7 +75,7 @@ class ElectronApplication extends import_channelOwner.ChannelOwner {
     return electronApplication._object;
   }
   process() {
-    return this._toImpl().process();
+    return this._connection.toImpl?.(this)?.process();
   }
   _onPage(page) {
     this._windows.add(page);