playwright-core 1.55.0-alpha-2025-07-29 → 1.55.0-alpha-1753913825000

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -52,12 +52,6 @@ class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   async setReportStateChanged(params, progress) {
     this._object.setReportStateChanged(params.enabled);
   }
-  async resetForReuse(params, progress) {
-    await this._object.resetForReuse(progress);
-  }
-  async navigate(params, progress) {
-    await this._object.navigate(progress, params.url);
-  }
   async setRecorderMode(params, progress) {
     await this._object.setRecorderMode(progress, params);
   }
@@ -73,9 +67,6 @@ class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   async kill(params, progress) {
     this._object.kill();
   }
-  async closeAllBrowsers(params, progress) {
-    await this._object.closeAllBrowsers();
-  }
   _onDispose() {
     import_utils.eventsHelper.removeEventListeners(this._listeners);
     this._object.dispose();

package/lib/server/dispatchers/localUtilsDispatcher.js

@@ -40,7 +40,6 @@ var import_jsonPipeDispatcher = require("../dispatchers/jsonPipeDispatcher");
 var import_socksInterceptor = require("../socksInterceptor");
 var import_transport = require("../transport");
 var import_network = require("../utils/network");
-var import_urlMatch = require("../../utils/isomorphic/urlMatch");
 class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, playwright) {
     const localUtils2 = new import_instrumentation.SdkObject(playwright, "localUtils", "localUtils");
@@ -112,10 +111,6 @@ class LocalUtilsDispatcher extends import_dispatcher.Dispatcher {
     pipe.on("close", () => transport.close());
     return { pipe, headers: transport.headers };
   }
-  async globToRegex(params, progress) {
-    const regex = (0, import_urlMatch.resolveGlobToRegexPattern)(params.baseURL, params.glob, params.webSocketUrl);
-    return { regex };
-  }
 }
 async function urlToWSEndpoint(progress, endpointURL) {
   if (endpointURL.startsWith("ws"))

package/lib/server/electron/electron.js

@@ -136,7 +136,6 @@ class Electron extends import_instrumentation.SdkObject {
         electronArguments.unshift("--no-sandbox");
     }
     const artifactsDir = await progress.race(import_fs.default.promises.mkdtemp(ARTIFACTS_FOLDER));
-    progress.cleanupWhenAborted(() => (0, import_utils.removeFolders)([artifactsDir]));
     const browserLogsCollector = new import_debugLogger.RecentLogsCollector();
     const env = options.env ? (0, import_processLauncher.envArrayToObject)(options.env) : process.env;
     let command;
@@ -195,73 +194,74 @@ class Electron extends import_instrumentation.SdkObject {
     const nodeMatchPromise = waitForLine(progress, launchedProcess, /^Debugger listening on (ws:\/\/.*)$/);
     const chromeMatchPromise = waitForLine(progress, launchedProcess, /^DevTools listening on (ws:\/\/.*)$/);
     const debuggerDisconnectPromise = waitForLine(progress, launchedProcess, /Waiting for the debugger to disconnect\.\.\./);
-    const nodeMatch = await nodeMatchPromise;
-    const nodeTransport = await import_transport.WebSocketTransport.connect(progress, nodeMatch[1]);
-    progress.cleanupWhenAborted(() => nodeTransport.close());
-    const nodeConnection = new import_crConnection.CRConnection(this, nodeTransport, import_helper.helper.debugProtocolLogger(), browserLogsCollector);
-    debuggerDisconnectPromise.then(() => {
-      nodeTransport.close();
-    }).catch(() => {
-    });
-    const chromeMatch = await Promise.race([
-      chromeMatchPromise,
-      waitForXserverError
-    ]);
-    const chromeTransport = await import_transport.WebSocketTransport.connect(progress, chromeMatch[1]);
-    progress.cleanupWhenAborted(() => chromeTransport.close());
-    const browserProcess = {
-      onclose: void 0,
-      process: launchedProcess,
-      close: gracefullyClose,
-      kill
-    };
-    const contextOptions = {
-      ...options,
-      noDefaultViewport: true
-    };
-    const browserOptions = {
-      name: "electron",
-      isChromium: true,
-      headful: true,
-      persistent: contextOptions,
-      browserProcess,
-      protocolLogger: import_helper.helper.debugProtocolLogger(),
-      browserLogsCollector,
-      artifactsDir,
-      downloadsPath: artifactsDir,
-      tracesDir: options.tracesDir || artifactsDir,
-      originalLaunchOptions: {}
-    };
-    (0, import_browserContext.validateBrowserContextOptions)(contextOptions, browserOptions);
-    const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
-    app = new ElectronApplication(this, browser, nodeConnection, launchedProcess);
-    await progress.race(app.initialize());
-    return app;
+    try {
+      const nodeMatch = await nodeMatchPromise;
+      const nodeTransport = await import_transport.WebSocketTransport.connect(progress, nodeMatch[1]);
+      const nodeConnection = new import_crConnection.CRConnection(this, nodeTransport, import_helper.helper.debugProtocolLogger(), browserLogsCollector);
+      debuggerDisconnectPromise.then(() => {
+        nodeTransport.close();
+      }).catch(() => {
+      });
+      const chromeMatch = await Promise.race([
+        chromeMatchPromise,
+        waitForXserverError
+      ]);
+      const chromeTransport = await import_transport.WebSocketTransport.connect(progress, chromeMatch[1]);
+      const browserProcess = {
+        onclose: void 0,
+        process: launchedProcess,
+        close: gracefullyClose,
+        kill
+      };
+      const contextOptions = {
+        ...options,
+        noDefaultViewport: true
+      };
+      const browserOptions = {
+        name: "electron",
+        isChromium: true,
+        headful: true,
+        persistent: contextOptions,
+        browserProcess,
+        protocolLogger: import_helper.helper.debugProtocolLogger(),
+        browserLogsCollector,
+        artifactsDir,
+        downloadsPath: artifactsDir,
+        tracesDir: options.tracesDir || artifactsDir,
+        originalLaunchOptions: {}
+      };
+      (0, import_browserContext.validateBrowserContextOptions)(contextOptions, browserOptions);
+      const browser = await progress.race(import_crBrowser.CRBrowser.connect(this.attribution.playwright, chromeTransport, browserOptions));
+      app = new ElectronApplication(this, browser, nodeConnection, launchedProcess);
+      await progress.race(app.initialize());
+      return app;
+    } catch (error) {
+      await kill();
+      throw error;
+    }
   }
 }
-function waitForLine(progress, process2, regex) {
-  return progress.race(new Promise((resolve, reject) => {
-    const rl = readline.createInterface({ input: process2.stderr });
-    const failError = new Error("Process failed to launch!");
-    const listeners = [
-      import_eventsHelper.eventsHelper.addEventListener(rl, "line", onLine),
-      import_eventsHelper.eventsHelper.addEventListener(rl, "close", reject.bind(null, failError)),
-      import_eventsHelper.eventsHelper.addEventListener(process2, "exit", reject.bind(null, failError)),
-      // It is Ok to remove error handler because we did not create process and there is another listener.
-      import_eventsHelper.eventsHelper.addEventListener(process2, "error", reject.bind(null, failError))
-    ];
-    progress.cleanupWhenAborted(cleanup);
-    function onLine(line) {
-      const match = line.match(regex);
-      if (!match)
-        return;
-      cleanup();
-      resolve(match);
-    }
-    function cleanup() {
-      import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    }
-  }));
+async function waitForLine(progress, process2, regex) {
+  const promise = new import_utils.ManualPromise();
+  const rl = readline.createInterface({ input: process2.stderr });
+  const failError = new Error("Process failed to launch!");
+  const listeners = [
+    import_eventsHelper.eventsHelper.addEventListener(rl, "line", onLine),
+    import_eventsHelper.eventsHelper.addEventListener(rl, "close", () => promise.reject(failError)),
+    import_eventsHelper.eventsHelper.addEventListener(process2, "exit", () => promise.reject(failError)),
+    // It is Ok to remove error handler because we did not create process and there is another listener.
+    import_eventsHelper.eventsHelper.addEventListener(process2, "error", () => promise.reject(failError))
+  ];
+  function onLine(line) {
+    const match = line.match(regex);
+    if (match)
+      promise.resolve(match);
+  }
+  try {
+    return await progress.race(promise);
+  } finally {
+    import_eventsHelper.eventsHelper.removeEventListeners(listeners);
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/fetch.js

@@ -221,6 +221,7 @@ ${text}`;
       postData
     };
     this.emit(APIRequestContext.Events.Request, requestEvent);
+    let destroyRequest;
     const resultPromise = new Promise((fulfill, reject) => {
       const requestConstructor = (url.protocol === "https:" ? import_https.default : import_http.default).request;
       const agent = options.agent || (url.protocol === "https:" ? import_happyEyeballs.httpsHappyEyeballsAgent : import_happyEyeballs.httpHappyEyeballsAgent);
@@ -379,7 +380,7 @@ ${text}`;
         body.on("end", notifyBodyFinished);
       });
       request.on("error", reject);
-      progress.cleanupWhenAborted(() => request.destroy());
+      destroyRequest = () => request.destroy();
       listeners.push(
         import_utils.eventsHelper.addEventListener(this, APIRequestContext.Events.Dispose, () => {
           reject(new Error("Request context disposed."));
@@ -431,7 +432,10 @@ ${text}`;
         request.write(postData);
       request.end();
     });
-    return progress.race(resultPromise);
+    return progress.race(resultPromise).catch((error) => {
+      destroyRequest?.();
+      throw error;
+    });
   }
   _getHttpCredentials(url) {
     if (!this._defaultOptions().httpCredentials?.origin || url.origin.toLowerCase() === this._defaultOptions().httpCredentials?.origin?.toLowerCase())

package/lib/server/frames.js

@@ -618,7 +618,7 @@ class Frame extends import_instrumentation.SdkObject {
           return null;
         return continuePolling;
       }
-      const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, root }) => {
+      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, root }) => {
         if (root && !root.isConnected)
           throw injected.createStacklessError("Element is not attached to the DOM");
         const elements = injected.querySelectorAll(info.parsed, root || document);
@@ -633,7 +633,7 @@ class Frame extends import_instrumentation.SdkObject {
           log2 = `  locator resolved to ${visible2 ? "visible" : "hidden"} ${injected.previewNode(element2)}`;
         }
         return { log: log2, element: element2, visible: visible2, attached: !!element2 };
-      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }), (handle) => handle.dispose());
+      }, { info: resolved.info, root: resolved.frame === this ? scope : void 0 }));
       const { log, visible, attached } = await progress.race(result.evaluate((r) => ({ log: r.log, visible: r.visible, attached: r.attached })));
       if (log)
         progress.log(log);
@@ -898,7 +898,7 @@ class Frame extends import_instrumentation.SdkObject {
       const resolved = await progress.race(this.selectors.resolveInjectedForSelector(selector, { strict }));
       if (!resolved)
         return continuePolling;
-      const result = await progress.raceWithCleanup(resolved.injected.evaluateHandle((injected, { info, callId }) => {
+      const result = await progress.race(resolved.injected.evaluateHandle((injected, { info, callId }) => {
         const elements = injected.querySelectorAll(info.parsed, document);
         if (callId)
           injected.markTargetElements(new Set(elements), callId);
@@ -912,7 +912,7 @@ class Frame extends import_instrumentation.SdkObject {
           log2 = `  locator resolved to ${injected.previewNode(element2)}`;
         }
         return { log: log2, success: !!element2, element: element2 };
-      }, { info: resolved.info, callId: progress.metadata.id }), (handle) => handle.dispose());
+      }, { info: resolved.info, callId: progress.metadata.id }));
       const { log, success } = await progress.race(result.evaluate((r) => ({ log: r.log, success: r.success })));
       if (log)
         progress.log(log);
@@ -982,8 +982,8 @@ class Frame extends import_instrumentation.SdkObject {
   async blur(progress, selector, options) {
     dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, options.strict, true, (handle) => handle._blur(progress)));
   }
-  async resolveSelector(progress, selector) {
-    const element = await progress.race(this.selectors.query(selector));
+  async resolveSelector(progress, selector, options = {}) {
+    const element = await progress.race(this.selectors.query(selector, options));
     if (!element)
       throw new Error(`No element matching ${selector}`);
     const generated = await progress.race(element.evaluateInUtility(async ([injected, node]) => {

package/lib/server/helper.js

@@ -51,22 +51,19 @@ class Helper {
   }
   static waitForEvent(progress, emitter, event, predicate) {
     const listeners = [];
-    const promise = new Promise((resolve, reject) => {
+    const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
+    const promise = progress.race(new Promise((resolve, reject) => {
       listeners.push(import_eventsHelper.eventsHelper.addEventListener(emitter, event, (eventArg) => {
         try {
           if (predicate && !predicate(eventArg))
             return;
-          import_eventsHelper.eventsHelper.removeEventListeners(listeners);
           resolve(eventArg);
         } catch (e) {
-          import_eventsHelper.eventsHelper.removeEventListeners(listeners);
           reject(e);
         }
       }));
-    });
-    const dispose = () => import_eventsHelper.eventsHelper.removeEventListeners(listeners);
-    progress.cleanupWhenAborted(dispose);
-    return { promise: progress.race(promise), dispose };
+    })).finally(() => dispose());
+    return { promise, dispose };
   }
   static secondsToRoundishMillis(value) {
     return (value * 1e6 | 0) / 1e3;

package/lib/server/localUtils.js

@@ -135,13 +135,18 @@ async function harOpen(progress, harBackends, params) {
   let harBackend;
   if (params.file.endsWith(".zip")) {
     const zipFile = new import_zipFile.ZipFile(params.file);
-    const entryNames = await zipFile.entries();
-    const harEntryName = entryNames.find((e) => e.endsWith(".har"));
-    if (!harEntryName)
-      return { error: "Specified archive does not have a .har file" };
-    const har = await progress.raceWithCleanup(zipFile.read(harEntryName), () => zipFile.close());
-    const harFile = JSON.parse(har.toString());
-    harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
+    try {
+      const entryNames = await progress.race(zipFile.entries());
+      const harEntryName = entryNames.find((e) => e.endsWith(".har"));
+      if (!harEntryName)
+        return { error: "Specified archive does not have a .har file" };
+      const har = await progress.race(zipFile.read(harEntryName));
+      const harFile = JSON.parse(har.toString());
+      harBackend = new import_harBackend.HarBackend(harFile, null, zipFile);
+    } catch (error) {
+      zipFile.close();
+      throw error;
+    }
   } else {
     const harFile = JSON.parse(await progress.race(import_fs.default.promises.readFile(params.file, "utf-8")));
     harBackend = new import_harBackend.HarBackend(harFile, import_path.default.dirname(params.file), null);
@@ -165,16 +170,18 @@ function harClose(harBackends, params) {
 async function harUnzip(progress, params) {
   const dir = import_path.default.dirname(params.zipFile);
   const zipFile = new import_zipFile.ZipFile(params.zipFile);
-  progress.cleanupWhenAborted(() => zipFile.close());
-  for (const entry of await progress.race(zipFile.entries())) {
-    const buffer = await progress.race(zipFile.read(entry));
-    if (entry === "har.har")
-      await progress.race(import_fs.default.promises.writeFile(params.harFile, buffer));
-    else
-      await progress.race(import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer));
+  try {
+    for (const entry of await progress.race(zipFile.entries())) {
+      const buffer = await progress.race(zipFile.read(entry));
+      if (entry === "har.har")
+        await progress.race(import_fs.default.promises.writeFile(params.harFile, buffer));
+      else
+        await progress.race(import_fs.default.promises.writeFile(import_path.default.join(dir, entry), buffer));
+    }
+    await progress.race(import_fs.default.promises.unlink(params.zipFile));
+  } finally {
+    zipFile.close();
   }
-  await progress.race(import_fs.default.promises.unlink(params.zipFile));
-  zipFile.close();
 }
 async function tracingStarted(progress, stackSessions, params) {
   let tmpDir = void 0;

package/lib/server/playwright.js

@@ -58,10 +58,6 @@ class Playwright extends import_instrumentation.SdkObject {
     this.android = new import_android.Android(this, new import_backendAdb.AdbBackend());
     this.debugController = new import_debugController.DebugController(this);
   }
-  async hideHighlight() {
-    await Promise.all([...this._allPages].map((p) => p.hideHighlight().catch(() => {
-    })));
-  }
   allBrowsers() {
     return [...this._allBrowsers];
   }

package/lib/server/progress.js

@@ -19,7 +19,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var progress_exports = {};
 __export(progress_exports, {
   ProgressController: () => ProgressController,
-  isAbortError: () => isAbortError
+  isAbortError: () => isAbortError,
+  raceUncancellableOperationWithCleanup: () => raceUncancellableOperationWithCleanup
 });
 module.exports = __toCommonJS(progress_exports);
 var import_errors = require("./errors");
@@ -67,15 +68,6 @@ class ProgressController {
         const promises = Array.isArray(promise) ? promise : [promise];
         return Promise.race([...promises, this._forceAbortPromise]);
       },
-      raceWithCleanup: (promise, cleanup) => {
-        return progress.race(promise.then((result) => {
-          if (this._state !== "running")
-            cleanup(result);
-          else
-            this._cleanups.push(() => cleanup(result));
-          return result;
-        }));
-      },
       wait: async (timeout2) => {
         let timer2;
         const promise = new Promise((f) => timer2 = setTimeout(f, timeout2));
@@ -117,8 +109,22 @@ const kAbortErrorSymbol = Symbol("kAbortError");
 function isAbortError(error) {
   return !!error[kAbortErrorSymbol];
 }
+async function raceUncancellableOperationWithCleanup(progress, run, cleanup) {
+  let aborted = false;
+  try {
+    return await progress.race(run().then(async (t) => {
+      if (aborted)
+        await cleanup(t);
+      return t;
+    }));
+  } catch (error) {
+    aborted = true;
+    throw error;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ProgressController,
-  isAbortError
+  isAbortError,
+  raceUncancellableOperationWithCleanup
 });

package/lib/server/recorder/recorderUtils.js

@@ -22,6 +22,7 @@ __export(recorderUtils_exports, {
   collapseActions: () => collapseActions,
   frameForAction: () => frameForAction,
   generateFrameSelector: () => generateFrameSelector,
+  isAssertAction: () => isAssertAction,
   mainFrameForAction: () => mainFrameForAction,
   metadataToCallLog: () => metadataToCallLog,
   shouldMergeAction: () => shouldMergeAction
@@ -75,6 +76,9 @@ async function frameForAction(pageAliases, actionInContext, action) {
     throw new Error("Internal error: frame not found");
   return result.frame;
 }
+function isAssertAction(action) {
+  return action.name.startsWith("assert");
+}
 function isSameAction(a, b) {
   return a.action.name === b.action.name && a.frame.pageAlias === b.frame.pageAlias && a.frame.framePath.join("|") === b.frame.framePath.join("|");
 }
@@ -151,6 +155,7 @@ async function generateFrameSelectorInParent(parent, frame) {
   collapseActions,
   frameForAction,
   generateFrameSelector,
+  isAssertAction,
   mainFrameForAction,
   metadataToCallLog,
   shouldMergeAction

package/lib/server/recorder.js

@@ -48,6 +48,8 @@ var import_utils2 = require("./../utils");
 var import_frames = require("./frames");
 var import_page = require("./page");
 var import_recorderRunner = require("./recorder/recorderRunner");
+var import_ariaSnapshot = require("../utils/isomorphic/ariaSnapshot");
+var import_utilsBundle = require("../utilsBundle");
 const recorderSymbol = Symbol("recorderSymbol");
 const RecorderEvent = {
   PausedStateChanged: "pausedStateChanged",
@@ -440,15 +442,66 @@ class Recorder extends import_events.default {
     };
     return actionInContext;
   }
+  async _maybeGenerateAssertAction(frame, actionInContext) {
+    const lastAction = getLastFrameAction(frame);
+    if ((0, import_recorderUtils.isAssertAction)(actionInContext.action))
+      return;
+    if (lastAction && ((0, import_recorderUtils.isAssertAction)(lastAction.action) || (0, import_recorderUtils.shouldMergeAction)(actionInContext, lastAction)))
+      return;
+    const newSnapshot = actionInContext.action.ariaSnapshot;
+    if (!newSnapshot)
+      return;
+    const lastSnapshot = lastAction?.action.ariaSnapshot || `- document [ref=e1]
+`;
+    if (!lastSnapshot)
+      return;
+    const callMetadata = (0, import_instrumentation.serverSideCallMetadata)();
+    const controller = new import_progress.ProgressController(callMetadata, frame);
+    const selector = await controller.run(async (progress) => {
+      const ref = (0, import_ariaSnapshot.findNewElementRef)(import_utilsBundle.yaml, lastSnapshot, newSnapshot);
+      if (!ref)
+        return;
+      const { resolvedSelector } = await frame.resolveSelector(progress, `aria-ref=${ref}`, { mainWorld: true }).catch(() => ({ resolvedSelector: void 0 }));
+      if (!resolvedSelector)
+        return;
+      const isVisible = await frame._page.mainFrame().isVisible(progress, resolvedSelector, { strict: true }).catch(() => false);
+      return isVisible ? resolvedSelector : void 0;
+    }).catch(() => void 0);
+    if (!selector)
+      return;
+    if (!actionInContext.frame.framePath.length && "selector" in actionInContext.action && actionInContext.action.selector === selector)
+      return;
+    const assertActionInContext = {
+      frame: {
+        pageGuid: actionInContext.frame.pageGuid,
+        pageAlias: actionInContext.frame.pageAlias,
+        framePath: []
+      },
+      action: {
+        name: "assertVisible",
+        selector,
+        signals: []
+      },
+      startTime: actionInContext.startTime,
+      endTime: actionInContext.startTime
+    };
+    return assertActionInContext;
+  }
   async _performAction(frame, action) {
     const actionInContext = await this._createActionInContext(frame, action);
+    const assertActionInContext = await this._maybeGenerateAssertAction(frame, actionInContext);
+    if (assertActionInContext)
+      this._signalProcessor.addAction(assertActionInContext);
     this._signalProcessor.addAction(actionInContext);
+    setLastFrameAction(frame, actionInContext);
     if (actionInContext.action.name !== "openPage" && actionInContext.action.name !== "closePage")
       await (0, import_recorderRunner.performAction)(this._pageAliases, actionInContext);
     actionInContext.endTime = (0, import_utils2.monotonicTime)();
   }
   async _recordAction(frame, action) {
-    this._signalProcessor.addAction(await this._createActionInContext(frame, action));
+    const actionInContext = await this._createActionInContext(frame, action);
+    this._signalProcessor.addAction(actionInContext);
+    setLastFrameAction(frame, actionInContext);
   }
   _onFrameNavigated(frame, page) {
     const pageAlias = this._pageAliases.get(page);
@@ -482,6 +535,13 @@ function languageForFile(file) {
     return "csharp";
   return "javascript";
 }
+const kLastFrameActionSymbol = Symbol("lastFrameAction");
+function getLastFrameAction(frame) {
+  return frame[kLastFrameActionSymbol];
+}
+function setLastFrameAction(frame, action) {
+  frame[kLastFrameActionSymbol] = action;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Recorder,