patchright-core 1.52.5 → 1.55.1

package/lib/server/clock.js

@@ -31,67 +31,79 @@ __export(clock_exports, {
   Clock: () => Clock
 });
 module.exports = __toCommonJS(clock_exports);
-var clockSource = __toESM(require("../generated/clockSource"));
+var rawClockSource = __toESM(require("../generated/clockSource"));
 class Clock {
   constructor(browserContext) {
-    this._scriptInstalled = false;
+    this._initScripts = [];
     this._browserContext = browserContext;
   }
-  markAsUninstalled() {
-    this._scriptInstalled = false;
+  async uninstall(progress) {
+    await progress.race(this._browserContext.removeInitScripts(this._initScripts));
+    this._initScripts = [];
   }
-  async fastForward(ticks) {
-    await this._installIfNeeded();
+  async fastForward(progress, ticks) {
+    await this._installIfNeeded(progress);
     const ticksMillis = parseTicks(ticks);
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('fastForward', ${Date.now()}, ${ticksMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.fastForward(${ticksMillis})`);
+    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})`));
   }
-  async install(time) {
-    await this._installIfNeeded();
+  async install(progress, time) {
+    await this._installIfNeeded(progress);
     const timeMillis = time !== void 0 ? parseTime(time) : Date.now();
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('install', ${Date.now()}, ${timeMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.install(${timeMillis})`);
+    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})`));
   }
-  async pauseAt(ticks) {
-    await this._installIfNeeded();
+  async pauseAt(progress, ticks) {
+    await this._installIfNeeded(progress);
     const timeMillis = parseTime(ticks);
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('pauseAt', ${Date.now()}, ${timeMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.pauseAt(${timeMillis})`);
+    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})`));
   }
-  async resume() {
-    await this._installIfNeeded();
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('resume', ${Date.now()})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.resume()`);
+  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()})`));
+      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()`));
   }
-  async setFixedTime(time) {
-    await this._installIfNeeded();
+  async setFixedTime(progress, time) {
+    await this._installIfNeeded(progress);
     const timeMillis = parseTime(time);
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setFixedTime', ${Date.now()}, ${timeMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.setFixedTime(${timeMillis})`);
+    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})`));
   }
-  async setSystemTime(time) {
-    await this._installIfNeeded();
+  async setSystemTime(progress, time) {
+    await this._installIfNeeded(progress);
     const timeMillis = parseTime(time);
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('setSystemTime', ${Date.now()}, ${timeMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.setSystemTime(${timeMillis})`);
+    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})`));
   }
-  async runFor(ticks) {
-    await this._installIfNeeded();
+  async runFor(progress, ticks) {
+    await this._installIfNeeded(progress);
     const ticksMillis = parseTicks(ticks);
-    await this._browserContext.addInitScript(`globalThis.__pwClock.controller.log('runFor', ${Date.now()}, ${ticksMillis})`);
-    await this._evaluateInFrames(`globalThis.__pwClock.controller.runFor(${ticksMillis})`);
+    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})`));
   }
-  async _installIfNeeded() {
-    if (this._scriptInstalled)
+  async _installIfNeeded(progress) {
+    if (this._initScripts.length)
       return;
-    this._scriptInstalled = true;
     const script = `(() => {
       const module = {};
-      ${clockSource.source}
-      globalThis.__pwClock = (module.exports.inject())(globalThis);
+      ${rawClockSource.source}
+      if (!globalThis.__pwClock)
+        globalThis.__pwClock = (module.exports.inject())(globalThis);
     })();`;
-    await this._browserContext.addInitScript(script);
-    await this._evaluateInFrames(script);
+    const initScript = await this._browserContext.addInitScript(progress, script);
+    await progress.race(this._evaluateInFrames(script));
+    this._initScripts.push(initScript);
   }
   async _evaluateInFrames(script) {
     await Promise.all(this._browserContext.pages().map(async (page) => {

package/lib/server/codegen/csharp.js

@@ -52,9 +52,7 @@ class CSharpLanguageGenerator {
     const action = actionInContext.action;
     if (this._mode !== "library" && (action.name === "openPage" || action.name === "closePage"))
       return "";
-    let pageAlias = actionInContext.frame.pageAlias;
-    if (this._mode !== "library")
-      pageAlias = pageAlias.replace("page", "Page");
+    const pageAlias = this._formatPageAlias(actionInContext.frame.pageAlias);
     const formatter = new CSharpFormatter(this._mode === "library" ? 0 : 8);
     if (action.name === "openPage") {
       formatter.add(`var ${pageAlias} = await context.NewPageAsync();`);
@@ -82,7 +80,7 @@ class CSharpLanguageGenerator {
       lines.push(`});`);
     }
     if (signals.popup) {
-      lines.unshift(`var ${signals.popup.popupAlias} = await ${pageAlias}.RunAndWaitForPopupAsync(async () =>
+      lines.unshift(`var ${this._formatPageAlias(signals.popup.popupAlias)} = await ${pageAlias}.RunAndWaitForPopupAsync(async () =>
 {`);
       lines.push(`});`);
     }
@@ -90,6 +88,13 @@ class CSharpLanguageGenerator {
       formatter.add(line);
     return formatter.format();
   }
+  _formatPageAlias(pageAlias) {
+    if (this._mode === "library")
+      return pageAlias;
+    if (pageAlias === "page")
+      return "Page";
+    return pageAlias;
+  }
   _generateActionCall(subject, actionInContext) {
     const action = actionInContext.action;
     switch (action.name) {
@@ -135,7 +140,7 @@ class CSharpLanguageGenerator {
         return `await Expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
       }
       case "assertSnapshot":
-        return `await Expect(${subject}.${this._asLocator(action.selector)}).ToMatchAriaSnapshotAsync(${quote(action.snapshot)});`;
+        return `await Expect(${subject}.${this._asLocator(action.selector)}).ToMatchAriaSnapshotAsync(${quote(action.ariaSnapshot)});`;
     }
   }
   _asLocator(selector) {

package/lib/server/codegen/java.js

@@ -119,7 +119,7 @@ class JavaLanguageGenerator {
         return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).${assertion};`;
       }
       case "assertSnapshot":
-        return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).matchesAriaSnapshot(${quote(action.snapshot)});`;
+        return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).matchesAriaSnapshot(${quote(action.ariaSnapshot)});`;
     }
   }
   _asLocator(selector, inFrameLocator) {

package/lib/server/codegen/javascript.js

@@ -110,7 +110,7 @@ class JavaScriptLanguageGenerator {
       }
       case "assertSnapshot": {
         const commentIfNeeded = this._isTest ? "" : "// ";
-        return `${commentIfNeeded}await expect(${subject}.${this._asLocator(action.selector)}).toMatchAriaSnapshot(${quoteMultiline(action.snapshot, `${commentIfNeeded}  `)});`;
+        return `${commentIfNeeded}await expect(${subject}.${this._asLocator(action.selector)}).toMatchAriaSnapshot(${quoteMultiline(action.ariaSnapshot, `${commentIfNeeded}  `)});`;
       }
     }
   }

package/lib/server/codegen/jsonl.js

@@ -34,7 +34,8 @@ class JsonlLanguageGenerator {
     const entry = {
       ...actionInContext.action,
       ...actionInContext.frame,
-      locator
+      locator,
+      ariaSnapshot: void 0
     };
     return JSON.stringify(entry);
   }

package/lib/server/codegen/language.js

@@ -29,10 +29,31 @@ module.exports = __toCommonJS(language_exports);
 function generateCode(actions, languageGenerator, options) {
   const header = languageGenerator.generateHeader(options);
   const footer = languageGenerator.generateFooter(options.saveStorage);
-  const actionTexts = actions.map((a) => languageGenerator.generateAction(a)).filter(Boolean);
+  const actionTexts = actions.map((a) => generateActionText(languageGenerator, a, !!options.generateAutoExpect)).filter(Boolean);
   const text = [header, ...actionTexts, footer].join("\n");
   return { header, footer, actionTexts, text };
 }
+function generateActionText(generator, action, generateAutoExpect) {
+  let text = generator.generateAction(action);
+  if (!text)
+    return;
+  if (generateAutoExpect && action.action.preconditionSelector) {
+    const expectAction = {
+      frame: action.frame,
+      startTime: action.startTime,
+      endTime: action.startTime,
+      action: {
+        name: "assertVisible",
+        selector: action.action.preconditionSelector,
+        signals: []
+      }
+    };
+    const expectText = generator.generateAction(expectAction);
+    if (expectText)
+      text = expectText + "\n\n" + text;
+  }
+  return text;
+}
 function sanitizeDeviceOptions(device, options) {
   const cleanedOptions = {};
   for (const property in options) {

package/lib/server/codegen/languages.js

@@ -28,15 +28,13 @@ var import_jsonl = require("./jsonl");
 var import_python = require("./python");
 function languageSet() {
   return /* @__PURE__ */ new Set([
-    new import_java.JavaLanguageGenerator("junit"),
-    new import_java.JavaLanguageGenerator("library"),
     new import_javascript.JavaScriptLanguageGenerator(
       /* isPlaywrightTest */
-      false
+      true
     ),
     new import_javascript.JavaScriptLanguageGenerator(
       /* isPlaywrightTest */
-      true
+      false
     ),
     new import_python.PythonLanguageGenerator(
       /* isAsync */
@@ -59,6 +57,8 @@ function languageSet() {
     new import_csharp.CSharpLanguageGenerator("mstest"),
     new import_csharp.CSharpLanguageGenerator("nunit"),
     new import_csharp.CSharpLanguageGenerator("library"),
+    new import_java.JavaLanguageGenerator("junit"),
+    new import_java.JavaLanguageGenerator("library"),
     new import_jsonl.JsonlLanguageGenerator()
   ]);
 }

package/lib/server/codegen/python.js

@@ -111,7 +111,7 @@ class PythonLanguageGenerator {
         return `expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
       }
       case "assertSnapshot":
-        return `expect(${subject}.${this._asLocator(action.selector)}).to_match_aria_snapshot(${quote(action.snapshot)})`;
+        return `expect(${subject}.${this._asLocator(action.selector)}).to_match_aria_snapshot(${quote(action.ariaSnapshot)})`;
     }
   }
   _asLocator(selector) {

package/lib/server/cookieStore.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var cookieStore_exports = {};
 __export(cookieStore_exports, {
+  Cookie: () => Cookie,
   CookieStore: () => CookieStore,
   domainMatches: () => domainMatches,
   parseRawCookie: () => parseRawCookie
@@ -33,7 +34,7 @@ class Cookie {
   }
   // https://datatracker.ietf.org/doc/html/rfc6265#section-5.4
   matches(url) {
-    if (this._raw.secure && (url.protocol !== "https:" && url.hostname !== "localhost"))
+    if (this._raw.secure && (url.protocol !== "https:" && !(0, import_network.isLocalHostname)(url.hostname)))
       return false;
     if (!domainMatches(url.hostname, this._raw.domain))
       return false;
@@ -198,6 +199,7 @@ function pathMatches(value, path) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Cookie,
   CookieStore,
   domainMatches,
   parseRawCookie

package/lib/server/debugController.js

@@ -27,14 +27,19 @@ var import_recorder = require("./recorder");
 var import_utils = require("../utils");
 var import_ariaSnapshot = require("../utils/isomorphic/ariaSnapshot");
 var import_utilsBundle = require("../utilsBundle");
-var import_recorderApp = require("./recorder/recorderApp");
 var import_locatorParser = require("../utils/isomorphic/locatorParser");
-const internalMetadata = (0, import_instrumentation.serverSideCallMetadata)();
+var import_language = require("./codegen/language");
+var import_recorderUtils = require("./recorder/recorderUtils");
+var import_javascript = require("./codegen/javascript");
+var import_frames = require("./frames");
+var import_page = require("./page");
 class DebugController extends import_instrumentation.SdkObject {
   constructor(playwright) {
     super({ attribution: { isInternalPlaywright: true }, instrumentation: (0, import_instrumentation.createInstrumentation)() }, void 0, "DebugController");
+    this._reportState = false;
+    this._disposeListeners = /* @__PURE__ */ new Set();
     this._sdkLanguage = "javascript";
-    this._codegenId = "playwright-test";
+    this._generateAutoExpect = false;
     this._playwright = playwright;
   }
   static {
@@ -47,105 +52,114 @@ class DebugController extends import_instrumentation.SdkObject {
     };
   }
   initialize(codegenId, sdkLanguage) {
-    this._codegenId = codegenId;
     this._sdkLanguage = sdkLanguage;
   }
   dispose() {
     this.setReportStateChanged(false);
   }
   setReportStateChanged(enabled) {
-    if (enabled && !this._trackHierarchyListener) {
-      this._trackHierarchyListener = {
-        onPageOpen: () => this._emitSnapshot(false),
+    if (this._reportState === enabled)
+      return;
+    this._reportState = enabled;
+    if (enabled) {
+      const listener = {
+        onPageOpen: (page) => {
+          this._emitSnapshot(false);
+          const handleNavigation = () => this._emitSnapshot(false);
+          page.mainFrame().on(import_frames.Frame.Events.InternalNavigation, handleNavigation);
+          const dispose = () => page.mainFrame().off(import_frames.Frame.Events.InternalNavigation, handleNavigation);
+          this._disposeListeners.add(dispose);
+          page.on(import_page.Page.Events.Close, () => this._disposeListeners.delete(dispose));
+        },
         onPageClose: () => this._emitSnapshot(false)
       };
-      this._playwright.instrumentation.addListener(this._trackHierarchyListener, null);
+      this._playwright.instrumentation.addListener(listener, null);
+      this._disposeListeners.add(() => this._playwright.instrumentation.removeListener(listener));
       this._emitSnapshot(true);
-    } else if (!enabled && this._trackHierarchyListener) {
-      this._playwright.instrumentation.removeListener(this._trackHierarchyListener);
-      this._trackHierarchyListener = void 0;
+    } else {
+      for (const dispose of this._disposeListeners)
+        dispose();
+      this._disposeListeners.clear();
     }
   }
-  async resetForReuse() {
-    const contexts = /* @__PURE__ */ new Set();
-    for (const page of this._playwright.allPages())
-      contexts.add(page.context());
-    for (const context of contexts)
-      await context.resetForReuse(internalMetadata, null);
-  }
-  async navigate(url) {
-    for (const p of this._playwright.allPages())
-      await p.mainFrame().goto(internalMetadata, url);
-  }
-  async setRecorderMode(params) {
-    await this._closeBrowsersWithoutPages();
+  async setRecorderMode(progress, params) {
+    await progress.race(this._closeBrowsersWithoutPages());
+    this._generateAutoExpect = !!params.generateAutoExpect;
     if (params.mode === "none") {
-      for (const recorder of await this._allRecorders()) {
+      for (const recorder of await progress.race(this._allRecorders())) {
         recorder.hideHighlightedSelector();
         recorder.setMode("none");
       }
       return;
     }
     if (!this._playwright.allBrowsers().length)
-      await this._playwright.chromium.launch(internalMetadata, { headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS });
+      await this._playwright.chromium.launch(progress, { headless: !!process.env.PW_DEBUG_CONTROLLER_HEADLESS });
     const pages = this._playwright.allPages();
     if (!pages.length) {
       const [browser] = this._playwright.allBrowsers();
-      const { context } = await browser.newContextForReuse({}, internalMetadata);
-      await context.newPage(internalMetadata);
+      const context = await browser.newContextForReuse(progress, {});
+      await context.newPage(progress);
     }
     if (params.testIdAttributeName) {
       for (const page of this._playwright.allPages())
-        page.context().selectors().setTestIdAttributeName(params.testIdAttributeName);
+        page.browserContext.selectors().setTestIdAttributeName(params.testIdAttributeName);
     }
-    for (const recorder of await this._allRecorders()) {
+    for (const recorder of await progress.race(this._allRecorders())) {
       recorder.hideHighlightedSelector();
-      if (params.mode !== "inspecting")
-        recorder.setOutput(this._codegenId, params.file);
       recorder.setMode(params.mode);
     }
   }
-  async highlight(params) {
+  async highlight(progress, params) {
     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;
-    for (const recorder of await this._allRecorders()) {
+    for (const recorder of await progress.race(this._allRecorders())) {
       if (ariaTemplate)
         recorder.setHighlightedAriaTemplate(ariaTemplate);
       else if (params.selector)
-        recorder.setHighlightedSelector(this._sdkLanguage, params.selector);
+        recorder.setHighlightedSelector(params.selector);
     }
   }
-  async hideHighlight() {
-    for (const recorder of await this._allRecorders())
+  async hideHighlight(progress) {
+    for (const recorder of await progress.race(this._allRecorders()))
       recorder.hideHighlightedSelector();
-    await this._playwright.hideHighlight();
-  }
-  allBrowsers() {
-    return [...this._playwright.allBrowsers()];
+    await Promise.all(this._playwright.allPages().map((p) => p.hideHighlight().catch(() => {
+    })));
   }
-  async resume() {
-    for (const recorder of await this._allRecorders())
+  async resume(progress) {
+    for (const recorder of await progress.race(this._allRecorders()))
       recorder.resume();
   }
-  async kill() {
+  kill() {
     (0, import_processLauncher.gracefullyProcessExitDoNotHang)(0);
   }
-  async closeAllBrowsers() {
-    await Promise.all(this.allBrowsers().map((browser) => browser.close({ reason: "Close all browsers requested" })));
-  }
   _emitSnapshot(initial) {
     const pageCount = this._playwright.allPages().length;
     if (initial && !pageCount)
       return;
-    this.emit(DebugController.Events.StateChanged, { pageCount });
+    this.emit(DebugController.Events.StateChanged, {
+      pageCount,
+      browsers: this._playwright.allBrowsers().map((browser) => ({
+        id: browser.guid,
+        name: browser.options.name,
+        channel: browser.options.channel,
+        contexts: browser.contexts().map((context) => ({
+          pages: context.pages().map((page) => ({
+            url: page.mainFrame().url()
+          }))
+        }))
+      }))
+    });
   }
   async _allRecorders() {
     const contexts = /* @__PURE__ */ new Set();
     for (const page of this._playwright.allPages())
-      contexts.add(page.context());
-    const result = await Promise.all([...contexts].map((c) => import_recorder.Recorder.showInspector(c, { omitCallTracking: true }, () => Promise.resolve(new InspectingRecorderApp(this)))));
-    return result.filter(Boolean);
+      contexts.add(page.browserContext);
+    const recorders = await Promise.all([...contexts].map((c) => import_recorder.Recorder.forContext(c, { omitCallTracking: true })));
+    const nonNullRecorders = recorders.filter(Boolean);
+    for (const recorder of recorders)
+      wireListeners(recorder, this);
+    return nonNullRecorders;
   }
   async _closeBrowsersWithoutPages() {
     for (const browser of this._playwright.allBrowsers()) {
@@ -158,26 +172,46 @@ class DebugController extends import_instrumentation.SdkObject {
     }
   }
 }
-class InspectingRecorderApp extends import_recorderApp.EmptyRecorderApp {
-  constructor(debugController) {
-    super();
-    this._debugController = debugController;
-  }
-  async elementPicked(elementInfo) {
-    const locator = (0, import_utils.asLocator)(this._debugController._sdkLanguage, elementInfo.selector);
-    this._debugController.emit(DebugController.Events.InspectRequested, { selector: elementInfo.selector, locator, ariaSnapshot: elementInfo.ariaSnapshot });
-  }
-  async setSources(sources) {
-    const source = sources.find((s) => s.id === this._debugController._codegenId);
-    const { text, header, footer, actions } = source || { text: "" };
-    this._debugController.emit(DebugController.Events.SourceChanged, { text, header, footer, actions });
-  }
-  async setPaused(paused) {
-    this._debugController.emit(DebugController.Events.Paused, { paused });
-  }
-  async setMode(mode) {
-    this._debugController.emit(DebugController.Events.SetModeRequested, { mode });
-  }
+const wiredSymbol = Symbol("wired");
+function wireListeners(recorder, debugController) {
+  if (recorder[wiredSymbol])
+    return;
+  recorder[wiredSymbol] = true;
+  const actions = [];
+  const languageGenerator = new import_javascript.JavaScriptLanguageGenerator(
+    /* isPlaywrightTest */
+    true
+  );
+  const actionsChanged = () => {
+    const aa = (0, import_recorderUtils.collapseActions)(actions);
+    const { header, footer, text, actionTexts } = (0, import_language.generateCode)(aa, languageGenerator, {
+      browserName: "chromium",
+      launchOptions: {},
+      contextOptions: {},
+      generateAutoExpect: debugController._generateAutoExpect
+    });
+    debugController.emit(DebugController.Events.SourceChanged, { text, header, footer, actions: actionTexts });
+  };
+  recorder.on(import_recorder.RecorderEvent.ElementPicked, (elementInfo) => {
+    const locator = (0, import_utils.asLocator)(debugController._sdkLanguage, elementInfo.selector);
+    debugController.emit(DebugController.Events.InspectRequested, { selector: elementInfo.selector, locator, ariaSnapshot: elementInfo.ariaSnapshot });
+  });
+  recorder.on(import_recorder.RecorderEvent.PausedStateChanged, (paused) => {
+    debugController.emit(DebugController.Events.Paused, { paused });
+  });
+  recorder.on(import_recorder.RecorderEvent.ModeChanged, (mode) => {
+    debugController.emit(DebugController.Events.SetModeRequested, { mode });
+  });
+  recorder.on(import_recorder.RecorderEvent.ActionAdded, (action) => {
+    actions.push(action);
+    actionsChanged();
+  });
+  recorder.on(import_recorder.RecorderEvent.SignalAdded, (signal) => {
+    const lastAction = actions.findLast((a) => a.frame.pageGuid === signal.frame.pageGuid);
+    if (lastAction)
+      lastAction.action.signals.push(signal.signal);
+    actionsChanged();
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/debugger.js

@@ -18,14 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var debugger_exports = {};
 __export(debugger_exports, {
-  Debugger: () => Debugger,
-  shouldSlowMo: () => shouldSlowMo
+  Debugger: () => Debugger
 });
 module.exports = __toCommonJS(debugger_exports);
 var import_events = require("events");
 var import_utils = require("../utils");
 var import_browserContext = require("./browserContext");
-var import_debug = require("../protocol/debug");
+var import_protocolMetainfo = require("../utils/isomorphic/protocolMetainfo");
 const symbol = Symbol("Debugger");
 class Debugger extends import_events.EventEmitter {
   constructor(context) {
@@ -42,7 +41,6 @@ class Debugger extends import_events.EventEmitter {
     this._context.once(import_browserContext.BrowserContext.Events.Close, () => {
       this._context.instrumentation.removeListener(this);
     });
-    this._slowMo = this._context._browser.options.slowMo;
   }
   static {
     this.Events = {
@@ -58,13 +56,6 @@ class Debugger extends import_events.EventEmitter {
     if (shouldPauseOnCall(sdkObject, metadata) || this._pauseOnNextStatement && shouldPauseBeforeStep(metadata))
       await this.pause(sdkObject, metadata);
   }
-  async _doSlowMo() {
-    await new Promise((f) => setTimeout(f, this._slowMo));
-  }
-  async onAfterCall(sdkObject, metadata) {
-    if (this._slowMo && shouldSlowMo(metadata))
-      await this._doSlowMo();
-  }
   async onBeforeInputAction(sdkObject, metadata) {
     if (this._muted)
       return;
@@ -117,20 +108,12 @@ function shouldPauseOnCall(sdkObject, metadata) {
   return metadata.method === "pause";
 }
 function shouldPauseBeforeStep(metadata) {
-  if (!metadata.apiName)
+  if (metadata.internal)
     return false;
-  if (metadata.method === "close")
-    return true;
-  if (metadata.method === "waitForSelector" || metadata.method === "waitForEventInfo" || metadata.method === "querySelector" || metadata.method === "querySelectorAll")
-    return false;
-  const step = metadata.type + "." + metadata.method;
-  return import_debug.commandsWithTracingSnapshots.has(step) && !import_debug.pausesBeforeInputActions.has(metadata.type + "." + metadata.method);
-}
-function shouldSlowMo(metadata) {
-  return import_debug.slowMoActions.has(metadata.type + "." + metadata.method);
+  const metainfo = import_protocolMetainfo.methodMetainfo.get(metadata.type + "." + metadata.method);
+  return !!metainfo?.pausesBeforeAction;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Debugger,
-  shouldSlowMo
+  Debugger
 });