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

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/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);

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,

package/lib/server/socksClientCertificatesInterceptor.js

@@ -44,6 +44,7 @@ var import_browserContext = require("./browserContext");
 var import_network = require("./utils/network");
 var import_debugLogger = require("./utils/debugLogger");
 var import_happyEyeballs = require("./utils/happyEyeballs");
+var import_utilsBundle = require("../utilsBundle");
 let dummyServerTlsOptions = void 0;
 function loadDummyServerCertsIfNeeded() {
   if (dummyServerTlsOptions)
@@ -97,8 +98,9 @@ class SocksProxyConnection {
     };
   }
   async connect() {
-    if (this.socksProxy.proxyAgentFromOptions)
-      this.target = await this.socksProxy.proxyAgentFromOptions.callback(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
+    const proxyAgent = this.socksProxy.getProxyAgent(this.host, this.port);
+    if (proxyAgent)
+      this.target = await proxyAgent.callback(new import_events.EventEmitter(), { host: rewriteToLocalhostIfNeeded(this.host), port: this.port, secureEndpoint: false });
     else
       this.target = await (0, import_happyEyeballs.createSocket)(rewriteToLocalhostIfNeeded(this.host), this.port);
     this.target.once("close", this._targetCloseEventListener);
@@ -222,7 +224,7 @@ class ClientCertificatesProxy {
     (0, import_browserContext.verifyClientCertificates)(contextOptions.clientCertificates);
     this.alpnCache = new ALPNCache();
     this.ignoreHTTPSErrors = contextOptions.ignoreHTTPSErrors;
-    this.proxyAgentFromOptions = (0, import_network.createProxyAgent)(contextOptions.proxy);
+    this._proxy = contextOptions.proxy;
     this._initSecureContexts(contextOptions.clientCertificates);
     this._socksProxy = new import_socksProxy.SocksProxy();
     this._socksProxy.setPattern("*");
@@ -245,6 +247,14 @@ class ClientCertificatesProxy {
     });
     loadDummyServerCertsIfNeeded();
   }
+  getProxyAgent(host, port) {
+    const proxyFromOptions = (0, import_network.createProxyAgent)(this._proxy);
+    if (proxyFromOptions)
+      return proxyFromOptions;
+    const proxyFromEnv = (0, import_utilsBundle.getProxyForUrl)(`https://${host}:${port}`);
+    if (proxyFromEnv)
+      return (0, import_network.createProxyAgent)({ server: proxyFromEnv });
+  }
   _initSecureContexts(clientCertificates) {
     const origin2certs = /* @__PURE__ */ new Map();
     for (const cert of clientCertificates || []) {
@@ -262,10 +272,15 @@ class ClientCertificatesProxy {
       }
     }
   }
-  static async create(contextOptions) {
+  static async create(progress, contextOptions) {
     const proxy = new ClientCertificatesProxy(contextOptions);
-    await proxy._socksProxy.listen(0, "127.0.0.1");
-    return proxy;
+    try {
+      await progress.race(proxy._socksProxy.listen(0, "127.0.0.1"));
+      return proxy;
+    } catch (error) {
+      await proxy.close();
+      throw error;
+    }
   }
   proxySettings() {
     return { server: `socks5://127.0.0.1:${this._socksProxy.port()}` };

package/lib/server/utils/processLauncher.js

@@ -132,7 +132,10 @@ async function launchProcess(options) {
     spawnedProcess.once("error", (error) => {
       failed(new Error("Failed to launch: " + error));
     });
-    return failedPromise.then((e) => Promise.reject(e));
+    return failedPromise.then(async (error) => {
+      await cleanup();
+      throw error;
+    });
   }
   options.log(`<launched> pid=${spawnedProcess.pid}`);
   const stdout = readline.createInterface({ input: spawnedProcess.stdout });

package/lib/utils/isomorphic/ariaSnapshot.js

@@ -20,13 +20,14 @@ var ariaSnapshot_exports = {};
 __export(ariaSnapshot_exports, {
   KeyParser: () => KeyParser,
   ParserError: () => ParserError,
+  findNewElementRef: () => findNewElementRef,
   parseAriaSnapshot: () => parseAriaSnapshot,
   parseAriaSnapshotUnsafe: () => parseAriaSnapshotUnsafe,
   valueOrRegex: () => valueOrRegex
 });
 module.exports = __toCommonJS(ariaSnapshot_exports);
-function parseAriaSnapshotUnsafe(yaml, text) {
-  const result = parseAriaSnapshot(yaml, text);
+function parseAriaSnapshotUnsafe(yaml, text, options = {}) {
+  const result = parseAriaSnapshot(yaml, text, options);
   if (result.errors.length)
     throw new Error(result.errors[0].message);
   return result.fragment;
@@ -187,7 +188,7 @@ function valueOrRegex(value) {
 class KeyParser {
   static parse(text, options, errors) {
     try {
-      return new KeyParser(text.value)._parse();
+      return new KeyParser(text.value, options)._parse();
     } catch (e) {
       if (e instanceof ParserError) {
         const message = options.prettyErrors === false ? e.message : e.message + ":\n\n" + text.value + "\n" + " ".repeat(e.pos) + "^\n";
@@ -200,10 +201,11 @@ class KeyParser {
       throw e;
     }
   }
-  constructor(input) {
+  constructor(input, options) {
     this._input = input;
     this._pos = 0;
     this._length = input.length;
+    this._options = options;
   }
   _peek() {
     return this._input[this._pos] || "";
@@ -331,6 +333,10 @@ class KeyParser {
     return result;
   }
   _applyAttribute(node, key, value, errorPos) {
+    if (this._options.allowRef && key === "ref") {
+      node.ref = value;
+      return;
+    }
     if (key === "checked") {
       this._assert(value === "true" || value === "false" || value === "mixed", 'Value of "checked" attribute must be a boolean or "mixed"', errorPos);
       node.checked = value === "true" ? true : value === "false" ? false : "mixed";
@@ -366,6 +372,8 @@ class KeyParser {
       node.selected = value === "true";
       return;
     }
+    if (this._options.allowUnknownAttributes)
+      return;
     this._assert(false, `Unsupported attribute [${key}]`, errorPos);
   }
   _assert(value, message, valuePos) {
@@ -379,10 +387,56 @@ class ParserError extends Error {
     this.pos = pos;
   }
 }
+function findNewElementRef(yaml, fromSnapshot, toSnapshot) {
+  function fillMap(root, map, position) {
+    let size = 1;
+    let childPosition = position + size;
+    for (const child of root.children || []) {
+      if (child.kind === "role") {
+        size += fillMap(child, map, childPosition);
+        childPosition += size;
+      } else {
+        size++;
+        childPosition++;
+      }
+    }
+    if (!["none", "presentation", "fragment", "iframe", "generic"].includes(root.role) && typeof root.name === "string" && root.name) {
+      let byRole = map.get(root.role);
+      if (!byRole) {
+        byRole = /* @__PURE__ */ new Map();
+        map.set(root.role, byRole);
+      }
+      const existing = byRole.get(root.name);
+      const sizeAndPosition = size * 100 - position;
+      if (!existing || existing.sizeAndPosition < sizeAndPosition)
+        byRole.set(root.name, { node: root, sizeAndPosition });
+    }
+    return size;
+  }
+  const fromMap = /* @__PURE__ */ new Map();
+  const from = parseAriaSnapshotUnsafe(yaml, fromSnapshot, { allowRef: true, allowUnknownAttributes: true });
+  if (from.kind === "role")
+    fillMap(from, fromMap, 0);
+  const toMap = /* @__PURE__ */ new Map();
+  const to = parseAriaSnapshotUnsafe(yaml, toSnapshot, { allowRef: true, allowUnknownAttributes: true });
+  if (to.kind === "role")
+    fillMap(to, toMap, 0);
+  const result = [];
+  for (const [role, byRole] of toMap) {
+    for (const [name, byName] of byRole) {
+      const inFrom = fromMap.get(role)?.get(name);
+      if (!inFrom)
+        result.push(byName);
+    }
+  }
+  result.sort((a, b) => b.sizeAndPosition - a.sizeAndPosition);
+  return result.find((r) => r.node.ref)?.node.ref;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   KeyParser,
   ParserError,
+  findNewElementRef,
   parseAriaSnapshot,
   parseAriaSnapshotUnsafe,
   valueOrRegex

package/lib/utils/isomorphic/protocolMetainfo.js

@@ -37,19 +37,15 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["LocalUtils.tracingStarted", { internal: true }],
   ["LocalUtils.addStackToTracingNoReply", { internal: true }],
   ["LocalUtils.traceDiscarded", { internal: true }],
-  ["LocalUtils.globToRegex", { internal: true }],
   ["Root.initialize", { internal: true }],
   ["Playwright.newRequest", { title: "Create request context" }],
   ["DebugController.initialize", { internal: true }],
   ["DebugController.setReportStateChanged", { internal: true }],
-  ["DebugController.resetForReuse", { internal: true }],
-  ["DebugController.navigate", { internal: true }],
   ["DebugController.setRecorderMode", { internal: true }],
   ["DebugController.highlight", { internal: true }],
   ["DebugController.hideHighlight", { internal: true }],
   ["DebugController.resume", { internal: true }],
   ["DebugController.kill", { internal: true }],
-  ["DebugController.closeAllBrowsers", { internal: true }],
   ["SocksSupport.socksConnected", { internal: true }],
   ["SocksSupport.socksFailed", { internal: true }],
   ["SocksSupport.socksData", { internal: true }],
@@ -107,7 +103,7 @@ const methodMetainfo = /* @__PURE__ */ new Map([
   ["BrowserContext.clockSetFixedTime", { title: 'Set fixed time "{timeNumber}{timeString}"' }],
   ["BrowserContext.clockSetSystemTime", { title: 'Set system time "{timeNumber}{timeString}"' }],
   ["Page.addInitScript", {}],
-  ["Page.close", { title: "Close" }],
+  ["Page.close", { title: "Close page" }],
   ["Page.emulateMedia", { title: "Emulate media", snapshot: true }],
   ["Page.exposeBinding", { title: "Expose binding" }],
   ["Page.goBack", { title: "Go back", slowMo: true, snapshot: true }],

package/lib/utils/isomorphic/urlMatch.js

@@ -20,7 +20,6 @@ var urlMatch_exports = {};
 __export(urlMatch_exports, {
   constructURLBasedOnBaseURL: () => constructURLBasedOnBaseURL,
   globToRegexPattern: () => globToRegexPattern,
-  resolveGlobToRegexPattern: () => resolveGlobToRegexPattern,
   urlMatches: () => urlMatches,
   urlMatchesEqual: () => urlMatchesEqual
 });
@@ -162,7 +161,6 @@ function constructURLBasedOnBaseURL(baseURL, givenURL) {
 0 && (module.exports = {
   constructURLBasedOnBaseURL,
   globToRegexPattern,
-  resolveGlobToRegexPattern,
   urlMatches,
   urlMatchesEqual
 });