patchright-bun-core 1.58.2 → 1.59.0

package/lib/server/chromium/crPage.js

@@ -40,6 +40,7 @@ var frames = __toESM(require("../frames"));
 var import_helper = require("../helper");
 var network = __toESM(require("../network"));
 var import_page = require("../page");
+var import_browserContext = require("../browserContext");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -50,6 +51,7 @@ var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
+var import_videoRecorder = require("../videoRecorder");
 class CRPage {
   constructor(client, targetId, browserContext, opener, bits) {
     this._sessions = /* @__PURE__ */ new Map();
@@ -201,7 +203,7 @@ class CRPage {
     await this._mainFrameSession._client.send("Emulation.setDefaultBackgroundColorOverride", { color });
   }
   async takeScreenshot(progress, format, documentRect, viewportRect, quality, fitsViewport, scale) {
-    const { visualViewport } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
+    const { visualViewport, contentSize, cssContentSize } = await progress.race(this._mainFrameSession._client.send("Page.getLayoutMetrics"));
     if (!documentRect) {
       documentRect = {
         x: visualViewport.pageX + viewportRect.x,
@@ -214,7 +216,7 @@ class CRPage {
     }
     const clip = { ...documentRect, scale: viewportRect ? visualViewport.scale : 1 };
     if (scale === "css") {
-      const deviceScaleFactor = this._browserContext._options.deviceScaleFactor || 1;
+      const deviceScaleFactor = this._mainFrameSession._metricsOverride?.deviceScaleFactor || contentSize.width / cssContentSize.width || 1;
       clip.scale /= deviceScaleFactor;
     }
     const result = await progress.race(this._mainFrameSession._client.send("Page.captureScreenshot", { format, quality, clip, captureBeyondViewport: !fitsViewport }));
@@ -232,16 +234,18 @@ class CRPage {
   async scrollRectIntoViewIfNeeded(handle, rect) {
     return this._sessionForHandle(handle)._scrollRectIntoViewIfNeeded(handle, rect);
   }
-  async startScreencast(options) {
-    await this._mainFrameSession._client.send("Page.startScreencast", {
+  startScreencast(options) {
+    this._mainFrameSession._client.send("Page.startScreencast", {
       format: "jpeg",
       quality: options.quality,
       maxWidth: options.width,
       maxHeight: options.height
+    }).catch(() => {
     });
   }
-  async stopScreencast() {
-    await this._mainFrameSession._client._sendMayFail("Page.stopScreencast");
+  stopScreencast() {
+    this._mainFrameSession._client._sendMayFail("Page.stopScreencast").catch(() => {
+    });
   }
   rafCountForStablePosition() {
     return 1;
@@ -293,6 +297,9 @@ class CRPage {
   shouldToggleStyleSheetToSyncAnimations() {
     return false;
   }
+  async setDockTile(image) {
+    await this._mainFrameSession._client.send("Browser.setDockTile", { image: image.toString("base64") });
+  }
 }
 class FrameSession {
   constructor(crPage, client, targetId, parentSession) {
@@ -357,9 +364,8 @@ class FrameSession {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let videoOptions;
-    if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
-      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
+    if (this._isMainFrame() && hasUIWindow && !this._page.isStorageStatePage)
+      (0, import_videoRecorder.startAutomaticVideoRecording)(this._crPage._page);
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -439,8 +445,6 @@ class FrameSession {
           true
           /* runImmediately */
         ));
-      if (videoOptions)
-        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
@@ -607,7 +611,7 @@ class FrameSession {
     session.on("Target.detachedFromTarget", (event2) => this._onDetachedFromTarget(event2));
     session.on("Runtime.consoleAPICalled", (event2) => {
       const args = event2.args.map((o) => (0, import_crExecutionContext.createHandle)(worker.existingExecutionContext, o));
-      this._page.addConsoleMessage(worker, event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
+      this._page.addConsoleMessage(worker, event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace), void 0, event2.timestamp);
     });
     session.on("Runtime.exceptionThrown", (exception) => this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails)));
   }
@@ -642,7 +646,7 @@ class FrameSession {
     if (!context)
       return;
     const values = event.args.map((arg) => (0, import_crExecutionContext.createHandle)(context, arg));
-    this._page.addConsoleMessage(null, event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+    this._page.addConsoleMessage(null, event.type, values, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace), void 0, event.timestamp);
   }
   async _onBindingCalled(event) {
     const pageOrError = await this._crPage._page.waitForInitializedOrError();
@@ -684,7 +688,7 @@ class FrameSession {
         lineNumber: lineNumber || 0,
         columnNumber: 0
       };
-      this._page.addConsoleMessage(null, level, [], location, text);
+      this._page.addConsoleMessage(null, level, [], location, text, event.entry.timestamp);
     }
   }
   async _onFileChooserOpened(event) {
@@ -708,15 +712,14 @@ class FrameSession {
     }
   }
   _onScreencastFrame(payload) {
-    this._page.screencast.throttleFrameAck(() => {
-      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
-    });
     const buffer = Buffer.from(payload.data, "base64");
-    this._page.emit(import_page.Page.Events.ScreencastFrame, {
+    this._page.screencast.onScreencastFrame({
       buffer,
       frameSwapWallTime: payload.metadata.timestamp ? payload.metadata.timestamp * 1e3 : Date.now(),
-      width: payload.metadata.deviceWidth,
-      height: payload.metadata.deviceHeight
+      viewportWidth: payload.metadata.deviceWidth,
+      viewportHeight: payload.metadata.deviceHeight
+    }, () => {
+      this._client._sendMayFail("Page.screencastFrameAck", { sessionId: payload.sessionId });
     });
   }
   async _updateGeolocation(initial) {
@@ -800,10 +803,12 @@ class FrameSession {
   }
   async _updateUserAgent() {
     const options = this._crPage._browserContext._options;
+    const { navigatorPlatform, userAgentMetadata } = (0, import_browserContext.calculateUserAgentEmulation)(options);
     await this._client.send("Emulation.setUserAgentOverride", {
       userAgent: options.userAgent || "",
       acceptLanguage: options.locale,
-      userAgentMetadata: calculateUserAgentMetadata(options)
+      platform: navigatorPlatform,
+      userAgentMetadata
     });
   }
   async _setDefaultFontFamilies(session) {
@@ -952,49 +957,6 @@ async function emulateTimezone(session, timezoneId) {
     throw exception;
   }
 }
-function calculateUserAgentMetadata(options) {
-  const ua = options.userAgent;
-  if (!ua)
-    return void 0;
-  const metadata = {
-    mobile: !!options.isMobile,
-    model: "",
-    architecture: "x86",
-    platform: "Windows",
-    platformVersion: ""
-  };
-  const androidMatch = ua.match(/Android (\d+(\.\d+)?(\.\d+)?)/);
-  const iPhoneMatch = ua.match(/iPhone OS (\d+(_\d+)?)/);
-  const iPadMatch = ua.match(/iPad; CPU OS (\d+(_\d+)?)/);
-  const macOSMatch = ua.match(/Mac OS X (\d+(_\d+)?(_\d+)?)/);
-  const windowsMatch = ua.match(/Windows\D+(\d+(\.\d+)?(\.\d+)?)/);
-  if (androidMatch) {
-    metadata.platform = "Android";
-    metadata.platformVersion = androidMatch[1];
-    metadata.architecture = "arm";
-  } else if (iPhoneMatch) {
-    metadata.platform = "iOS";
-    metadata.platformVersion = iPhoneMatch[1];
-    metadata.architecture = "arm";
-  } else if (iPadMatch) {
-    metadata.platform = "iOS";
-    metadata.platformVersion = iPadMatch[1];
-    metadata.architecture = "arm";
-  } else if (macOSMatch) {
-    metadata.platform = "macOS";
-    metadata.platformVersion = macOSMatch[1];
-    if (!ua.includes("Intel"))
-      metadata.architecture = "arm";
-  } else if (windowsMatch) {
-    metadata.platform = "Windows";
-    metadata.platformVersion = windowsMatch[1];
-  } else if (ua.toLowerCase().includes("linux")) {
-    metadata.platform = "Linux";
-  }
-  if (ua.includes("ARM"))
-    metadata.architecture = "arm";
-  return metadata;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CRPage

package/lib/server/chromium/crServiceWorker.js

@@ -45,13 +45,14 @@ class CRServiceWorker extends import_page.Worker {
     this.browserContext = browserContext;
     if (!process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_NETWORK)
       this._networkManager = new import_crNetworkManager.CRNetworkManager(null, this);
-    session.once("Runtime.executionContextCreated", (event) => {
+    session.on("Inspector.targetCrashed", () => this._prepareContextForRestart());
+    session.on("Runtime.executionContextCreated", (event) => {
       this.createExecutionContext(new import_crExecutionContext.CRExecutionContext(session, event.context));
+      if (this.browserContext._browser.majorVersion() < 143)
+        this.workerScriptLoaded();
     });
     if (this.browserContext._browser.majorVersion() >= 143)
       session.on("Inspector.workerScriptLoaded", () => this.workerScriptLoaded());
-    else
-      this.workerScriptLoaded();
     if (this._networkManager && this._isNetworkInspectionEnabled()) {
       this.updateRequestInterception();
       this.updateExtraHTTPHeaders();
@@ -69,7 +70,7 @@ class CRServiceWorker extends import_page.Worker {
       if (!this.existingExecutionContext || process.env.PLAYWRIGHT_DISABLE_SERVICE_WORKER_CONSOLE)
         return;
       const args = event.args.map((o) => (0, import_crExecutionContext.createHandle)(this.existingExecutionContext, o));
-      const message = new import_console.ConsoleMessage(null, this, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace));
+      const message = new import_console.ConsoleMessage(null, this, event.type, void 0, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event.stackTrace), event.timestamp);
       this.browserContext.emit(import_browserContext.BrowserContext.Events.Console, message);
     });
     session.send("Runtime.enable", {}).catch((e) => {

package/lib/server/clock.js

@@ -38,71 +38,71 @@ class Clock {
     this._browserContext = browserContext;
   }
   async uninstall(progress) {
-    await progress.race(this._browserContext.removeInitScripts(this._initScripts));
+    await progress.race(Promise.all(this._initScripts.map((script) => script.dispose())));
     this._initScripts = [];
   }
-  async fastForward(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async fastForward(ticks) {
+    await this._installIfNeeded();
     const ticksMillis = parseTicks(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
   }
-  async install(progress, time) {
-    await this._installIfNeeded(progress);
+  async install(time) {
+    await this._installIfNeeded();
     const timeMillis = time !== void 0 ? parseTime(time) : Date.now();
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
   }
-  async pauseAt(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async pauseAt(ticks) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
   }
   resumeNoReply() {
     if (!this._initScripts.length)
       return;
     const doResume = async () => {
-      this._initScripts.push(await this._browserContext.addInitScript(void 0, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+      this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
       await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
     };
     doResume().catch(() => {
     });
   }
   async resume(progress) {
-    await this._installIfNeeded(progress);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`));
+    await this._installIfNeeded();
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
   }
-  async setFixedTime(progress, time) {
-    await this._installIfNeeded(progress);
+  async setFixedTime(time) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(time);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
   }
-  async setSystemTime(progress, time) {
-    await this._installIfNeeded(progress);
+  async setSystemTime(time) {
+    await this._installIfNeeded();
     const timeMillis = parseTime(time);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
   }
-  async runFor(progress, ticks) {
-    await this._installIfNeeded(progress);
+  async runFor(ticks) {
+    await this._installIfNeeded();
     const ticksMillis = parseTicks(ticks);
-    this._initScripts.push(await this._browserContext.addInitScript(progress, `globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
-    await progress.race(this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`));
+    this._initScripts.push(await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`));
+    await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
   }
-  async _installIfNeeded(progress) {
+  async _installIfNeeded() {
     if (this._initScripts.length)
       return;
     const script = `(() => {
       const module = {};
       ${rawClockSource.source}
       if (!globalThis.__pwClock)
-        globalThis.__pwClock = (module.exports.inject())(globalThis);
+        globalThis.__pwClock = (module.exports.inject())(globalThis, ${JSON.stringify(this._browserContext._browser.options.name)});
     })();`;
-    const initScript = await this._browserContext.addInitScript(progress, script);
-    await progress.race(this._evaluateInFrames(script));
+    const initScript = await this._browserContext.addInitScript(script);
+    await this._evaluateInFrames(script);
     this._initScripts.push(initScript);
   }
   async _evaluateInFrames(script) {

package/lib/server/console.js

@@ -22,13 +22,14 @@ __export(console_exports, {
 });
 module.exports = __toCommonJS(console_exports);
 class ConsoleMessage {
-  constructor(page, worker, type, text, args, location) {
+  constructor(page, worker, type, text, args, location, timestamp) {
     this._page = page;
     this._worker = worker;
     this._type = type;
     this._text = text;
     this._args = args;
     this._location = location || { url: "", lineNumber: 0, columnNumber: 0 };
+    this._timestamp = timestamp;
   }
   page() {
     return this._page;
@@ -50,6 +51,9 @@ class ConsoleMessage {
   location() {
     return this._location;
   }
+  timestamp() {
+    return this._timestamp;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/debugController.js

@@ -70,10 +70,12 @@ class DebugController extends import_instrumentation.SdkObject {
     await progress.race(this._closeBrowsersWithoutPages());
     this._generateAutoExpect = !!params.generateAutoExpect;
     if (params.mode === "none") {
+      const promises = [];
       for (const recorder of await progress.race(this._allRecorders())) {
-        recorder.hideHighlightedSelector();
-        recorder.setMode("none");
+        promises.push(recorder.hideHighlightedSelector());
+        promises.push(recorder.setMode("none"));
       }
+      await Promise.all(promises);
       return;
     }
     if (!this._playwright.allBrowsers().length)
@@ -97,18 +99,22 @@ class DebugController extends import_instrumentation.SdkObject {
     if (params.selector)
       (0, import_locatorParser.unsafeLocatorOrSelectorAsSelector)(this._sdkLanguage, params.selector, "data-testid");
     const ariaTemplate = params.ariaTemplate ? (0, import_ariaSnapshot.parseAriaSnapshotUnsafe)(import_utilsBundle.yaml, params.ariaTemplate) : void 0;
+    const promises = [];
     for (const recorder of await progress.race(this._allRecorders())) {
       if (ariaTemplate)
-        recorder.setHighlightedAriaTemplate(ariaTemplate);
+        promises.push(recorder.setHighlightedAriaTemplate(ariaTemplate));
       else if (params.selector)
-        recorder.setHighlightedSelector(params.selector);
+        promises.push(recorder.setHighlightedSelector(params.selector));
     }
+    await Promise.all(promises);
   }
   async hideHighlight(progress) {
+    const promises = [];
     for (const recorder of await progress.race(this._allRecorders()))
-      recorder.hideHighlightedSelector();
-    await Promise.all(this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
+      promises.push(recorder.hideHighlightedSelector());
+    promises.push(...this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
     })));
+    await Promise.all(promises);
   }
   async resume(progress) {
     for (const recorder of await progress.race(this._allRecorders()))

package/lib/server/debugger.js

@@ -21,22 +21,20 @@ __export(debugger_exports, {
   Debugger: () => Debugger
 });
 module.exports = __toCommonJS(debugger_exports);
-var import_events = require("events");
+var import_instrumentation = require("./instrumentation");
 var import_utils = require("../utils");
 var import_browserContext = require("./browserContext");
 var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
 const symbol = Symbol("Debugger");
-class Debugger extends import_events.EventEmitter {
+class Debugger extends import_instrumentation.SdkObject {
   constructor(context) {
-    super();
-    this._pauseOnNextStatement = false;
-    this._pausedCallsMetadata = /* @__PURE__ */ new Map();
+    super(context, "debugger");
+    this._pauseAt = {};
+    this._enabled = false;
+    this._pauseBeforeWaitingActions = false;
     this._muted = false;
     this._context = context;
     this._context[symbol] = this;
-    this._enabled = (0, import_utils.debugMode)() === "inspector";
-    if (this._enabled)
-      this.pauseOnNextStatement();
     context.instrumentation.addListener(this, context);
     this._context.once(import_browserContext.BrowserContext.Events.Close, () => {
       this._context.instrumentation.removeListener(this);
@@ -51,67 +49,62 @@ class Debugger extends import_events.EventEmitter {
     this._muted = muted;
   }
   async onBeforeCall(sdkObject, metadata) {
-    if (this._muted)
+    if (this._muted || metadata.internal)
       return;
-    if (shouldPauseOnCall(sdkObject, metadata) || this._pauseOnNextStatement && shouldPauseBeforeStep(metadata))
-      await this.pause(sdkObject, metadata);
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    const pauseOnPauseCall = this._enabled && metadata.type === "BrowserContext" && metadata.method === "pause";
+    const pauseBeforeAction = !!this._pauseAt.next && !!metainfo?.pause && (this._pauseBeforeWaitingActions || !metainfo?.isAutoWaiting);
+    const pauseOnLocation = !!this._pauseAt.location && matchesLocation(metadata, this._pauseAt.location);
+    if (pauseOnPauseCall || pauseBeforeAction || pauseOnLocation)
+      await this._pause(sdkObject, metadata);
   }
   async onBeforeInputAction(sdkObject, metadata) {
-    if (this._muted)
+    if (this._muted || metadata.internal)
       return;
-    if (this._enabled && this._pauseOnNextStatement)
-      await this.pause(sdkObject, metadata);
+    const metainfo = (0, import_protocolMetainfo.getMetainfo)(metadata);
+    const pauseBeforeInput = !!this._pauseAt.next && !!metainfo?.pause && !!metainfo?.isAutoWaiting && !this._pauseBeforeWaitingActions;
+    if (pauseBeforeInput)
+      await this._pause(sdkObject, metadata);
   }
-  async pause(sdkObject, metadata) {
-    if (this._muted)
+  async _pause(sdkObject, metadata) {
+    if (this._muted || metadata.internal)
       return;
-    this._enabled = true;
+    if (this._pausedCall)
+      return;
+    this._pauseAt = {};
     metadata.pauseStartTime = (0, import_utils.monotonicTime)();
     const result = new Promise((resolve) => {
-      this._pausedCallsMetadata.set(metadata, { resolve, sdkObject });
+      this._pausedCall = { metadata, sdkObject, resolve };
     });
     this.emit(Debugger.Events.PausedStateChanged);
     return result;
   }
-  resume(step) {
-    if (!this.isPaused())
+  resume() {
+    if (!this._pausedCall)
       return;
-    this._pauseOnNextStatement = step;
-    const endTime = (0, import_utils.monotonicTime)();
-    for (const [metadata, { resolve }] of this._pausedCallsMetadata) {
-      metadata.pauseEndTime = endTime;
-      resolve();
-    }
-    this._pausedCallsMetadata.clear();
+    this._pausedCall.metadata.pauseEndTime = (0, import_utils.monotonicTime)();
+    this._pausedCall.resolve();
+    this._pausedCall = void 0;
     this.emit(Debugger.Events.PausedStateChanged);
   }
-  pauseOnNextStatement() {
-    this._pauseOnNextStatement = true;
+  setPauseBeforeWaitingActions() {
+    this._pauseBeforeWaitingActions = true;
+  }
+  setPauseAt(at = {}) {
+    this._enabled = true;
+    this._pauseAt = at;
   }
   isPaused(metadata) {
     if (metadata)
-      return this._pausedCallsMetadata.has(metadata);
-    return !!this._pausedCallsMetadata.size;
+      return this._pausedCall?.metadata === metadata;
+    return !!this._pausedCall;
   }
   pausedDetails() {
-    const result = [];
-    for (const [metadata, { sdkObject }] of this._pausedCallsMetadata)
-      result.push({ metadata, sdkObject });
-    return result;
+    return this._pausedCall;
   }
 }
-function shouldPauseOnCall(sdkObject, metadata) {
-  if (sdkObject.attribution.playwright.options.isServer)
-    return false;
-  if (!sdkObject.attribution.browser?.options.headful && !(0, import_utils.isUnderTest)())
-    return false;
-  return metadata.method === "pause";
-}
-function shouldPauseBeforeStep(metadata) {
-  if (metadata.internal)
-    return false;
-  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
-  return !!metainfo?.pausesBeforeAction;
+function matchesLocation(metadata, location) {
+  return !!metadata.location?.file.includes(location.file) && (location.line === void 0 || metadata.location.line === location.line) && (location.column === void 0 || metadata.location.column === location.column);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {