patchright-core 1.55.3 → 1.56.1

package/lib/server/chromium/crBrowser.js

@@ -51,7 +51,6 @@ class CRBrowser extends import_browser.Browser {
     this._clientRootSessionPromise = null;
     this._contexts = /* @__PURE__ */ new Map();
     this._crPages = /* @__PURE__ */ new Map();
-    this._backgroundPages = /* @__PURE__ */ new Map();
     this._serviceWorkers = /* @__PURE__ */ new Map();
     this._version = "";
     this._tracingRecording = false;
@@ -133,7 +132,7 @@ class CRBrowser extends import_browser.Browser {
   async _waitForAllPagesToBeInitialized() {
     await Promise.all([...this._crPages.values()].map((crPage) => crPage._page.waitForInitializedOrError()));
   }
-  _onAttachedToTarget({ targetInfo, sessionId }) {
+  _onAttachedToTarget({ targetInfo, sessionId, waitingForDebugger }) {
     if (targetInfo.type === "browser")
       return;
     const session = this._session.createChildSession(sessionId);
@@ -153,16 +152,10 @@ class CRBrowser extends import_browser.Browser {
       return;
     }
     (0, import_assert.assert)(!this._crPages.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
-    (0, import_assert.assert)(!this._backgroundPages.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
     (0, import_assert.assert)(!this._serviceWorkers.has(targetInfo.targetId), "Duplicate target " + targetInfo.targetId);
-    if (targetInfo.type === "background_page") {
-      const backgroundPage = new import_crPage.CRPage(session, targetInfo.targetId, context, null, { hasUIWindow: false, isBackgroundPage: true });
-      this._backgroundPages.set(targetInfo.targetId, backgroundPage);
-      return;
-    }
     if (targetInfo.type === "page" || treatOtherAsPage) {
       const opener = targetInfo.openerId ? this._crPages.get(targetInfo.openerId) || null : null;
-      const crPage = new import_crPage.CRPage(session, targetInfo.targetId, context, opener, { hasUIWindow: targetInfo.type === "page", isBackgroundPage: false });
+      const crPage = new import_crPage.CRPage(session, targetInfo.targetId, context, opener, { hasUIWindow: targetInfo.type === "page" });
       this._crPages.set(targetInfo.targetId, crPage);
       return;
     }
@@ -183,12 +176,6 @@ class CRBrowser extends import_browser.Browser {
       crPage.didClose();
       return;
     }
-    const backgroundPage = this._backgroundPages.get(targetId);
-    if (backgroundPage) {
-      this._backgroundPages.delete(targetId);
-      backgroundPage.didClose();
-      return;
-    }
     const serviceWorker = this._serviceWorkers.get(targetId);
     if (serviceWorker) {
       this._serviceWorkers.delete(targetId);
@@ -200,9 +187,6 @@ class CRBrowser extends import_browser.Browser {
     for (const crPage of this._crPages.values())
       crPage.didClose();
     this._crPages.clear();
-    for (const backgroundPage of this._backgroundPages.values())
-      backgroundPage.didClose();
-    this._backgroundPages.clear();
     for (const serviceWorker of this._serviceWorkers.values())
       serviceWorker.didClose();
     this._serviceWorkers.clear();
@@ -295,7 +279,6 @@ class CRBrowser extends import_browser.Browser {
 class CRBrowserContext extends import_browserContext.BrowserContext {
   static {
     this.CREvents = {
-      BackgroundPage: "backgroundpage",
       ServiceWorker: "serviceworker"
     };
   }
@@ -396,7 +379,8 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       // chrome-specific permissions we have.
       ["midi-sysex", "midiSysex"],
       ["storage-access", "storageAccess"],
-      ["local-fonts", "localFonts"]
+      ["local-fonts", "localFonts"],
+      ["local-network-access", "localNetworkAccess"]
     ]);
     const filtered = permissions.map((permission) => {
       const protocolPermission = webPermissionToProtocol.get(permission);
@@ -480,12 +464,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
     await Promise.all(this._crPages().map((crPage) => crPage._mainFrameSession._stopVideoRecording()));
   }
   onClosePersistent() {
-    for (const [targetId, backgroundPage] of this._browser._backgroundPages.entries()) {
-      if (backgroundPage._browserContext === this && backgroundPage._page.initializedOrUndefined()) {
-        backgroundPage.didClose();
-        this._browser._backgroundPages.delete(targetId);
-      }
-    }
   }
   async clearCache() {
     for (const page of this._crPages())
@@ -497,14 +475,6 @@ class CRBrowserContext extends import_browserContext.BrowserContext {
       browserContextId: this._browserContextId
     });
   }
-  backgroundPages() {
-    const result = [];
-    for (const backgroundPage of this._browser._backgroundPages.values()) {
-      if (backgroundPage._browserContext === this && backgroundPage._page.initializedOrUndefined())
-        result.push(backgroundPage._page);
-    }
-    return result;
-  }
   serviceWorkers() {
     return Array.from(this._browser._serviceWorkers.values()).filter((serviceWorker) => serviceWorker.browserContext === this);
   }

package/lib/server/chromium/crPage.js

@@ -45,7 +45,6 @@ var network = __toESM(require("../network"));
 var import_page = require("../page");
 var import_registry = require("../registry");
 var import_crAccessibility = require("./crAccessibility");
-var import_crBrowser = require("./crBrowser");
 var import_crCoverage = require("./crCoverage");
 var import_crDragDrop = require("./crDragDrop");
 var import_crExecutionContext = require("./crExecutionContext");
@@ -55,7 +54,6 @@ var import_crPdf = require("./crPdf");
 var import_crProtocolHelper = require("./crProtocolHelper");
 var import_defaultFontFamilies = require("./defaultFontFamilies");
 var import_videoRecorder = require("./videoRecorder");
-var import_browserContext = require("../browserContext");
 var import_errors = require("../errors");
 var import_protocolError = require("../protocolError");
 class CRPage {
@@ -69,7 +67,6 @@ class CRPage {
     this._nextWindowOpenPopupFeatures = [];
     this._targetId = targetId;
     this._opener = opener;
-    this._isBackgroundPage = bits.isBackgroundPage;
     const dragManager = new import_crDragDrop.DragManager(this);
     this.rawKeyboard = new import_crInput.RawKeyboardImpl(client, browserContext._browser._platform() === "mac", dragManager);
     this.rawMouse = new import_crInput.RawMouseImpl(this, client, dragManager);
@@ -93,10 +90,9 @@ class CRPage {
       if (viewportSize)
         this._page.setEmulatedSizeFromWindowOpen({ viewport: viewportSize, screen: viewportSize });
     }
-    const createdEvent = this._isBackgroundPage ? import_crBrowser.CRBrowserContext.CREvents.BackgroundPage : import_browserContext.BrowserContext.Events.Page;
     this._mainFrameSession._initialize(bits.hasUIWindow).then(
-      () => this._page.reportAsNew(this._opener?._page, void 0, createdEvent),
-      (error) => this._page.reportAsNew(this._opener?._page, error, createdEvent)
+      () => this._page.reportAsNew(this._opener?._page, void 0),
+      (error) => this._page.reportAsNew(this._opener?._page, error)
     );
   }
   static mainFrameSession(page) {
@@ -371,13 +367,13 @@ class FrameSession {
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.exceptionThrown", (exception) => this._handleException(exception.exceptionDetails)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextCreated", (event) => this._onExecutionContextCreated(event.context)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextDestroyed", (event) => this._onExecutionContextDestroyed(event.executionContextId)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", (event) => this._onExecutionContextsCleared()),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.attachedToTarget", (event) => this._onAttachedToTarget(event)),
-      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.detachedFromTarget", (event) => this._onDetachedFromTarget(event))
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Runtime.executionContextsCleared", (event) => this._onExecutionContextsCleared())
     ]);
   }
   _addBrowserListeners() {
     this._eventListeners.push(...[
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.attachedToTarget", (event) => this._onAttachedToTarget(event)),
+      import_eventsHelper.eventsHelper.addEventListener(this._client, "Target.detachedFromTarget", (event) => this._onDetachedFromTarget(event)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Inspector.targetCrashed", (event) => this._onTargetCrashed()),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.screencastFrame", (event) => this._onScreencastFrame(event)),
       import_eventsHelper.eventsHelper.addEventListener(this._client, "Page.windowOpen", (event) => this._onWindowOpen(event))
@@ -409,6 +405,7 @@ class FrameSession {
     if (!this._isMainFrame())
       this._addRendererListeners();
     this._addBrowserListeners();
+    this._bufferedAttachedToTargetEvents = [];
     const promises = [
       this._client.send("Page.enable"),
       this._client.send("Page.getFrameTree").then(({ frameTree }) => {
@@ -416,6 +413,10 @@ class FrameSession {
           this._handleFrameTree(frameTree);
           this._addRendererListeners();
         }
+        const attachedToTargetEvents = this._bufferedAttachedToTargetEvents || [];
+        this._bufferedAttachedToTargetEvents = void 0;
+        for (const event of attachedToTargetEvents)
+          this._onAttachedToTarget(event);
         const isInitialEmptyPage = this._isMainFrame() && this._page.mainFrame().url() === ":";
         if (isInitialEmptyPage) {
           lifecycleEventsEnabled.catch((e) => {
@@ -444,16 +445,7 @@ class FrameSession {
         worldName: this._crPage.utilityWorldName
       }),
       this._crPage._networkManager.addSession(this._client, void 0, this._isMainFrame()),
-      this._client.send("Target.setAutoAttach", {
-        autoAttach: true,
-        waitForDebuggerOnStart: true,
-        flatten: true,
-        filter: [
-          { type: "iframe" },
-          { type: "worker" },
-          { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
-        ]
-      })
+      this._client.send("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true })
     ];
     if (!this._page.isStorageStatePage) {
       if (this._crPage._browserContext.needsPlaywrightBinding())
@@ -644,10 +636,17 @@ class FrameSession {
       this._onExecutionContextDestroyed(contextId);
   }
   async _onAttachedToTarget(event) {
+    if (this._bufferedAttachedToTargetEvents) {
+      this._bufferedAttachedToTargetEvents.push(event);
+      return;
+    }
     const session = this._client.createChildSession(event.sessionId);
     if (event.targetInfo.type === "iframe") {
       const targetId = event.targetInfo.targetId;
-      const frame = this._page.frameManager.frame(targetId);
+      let frame = this._page.frameManager.frame(targetId);
+      if (!frame && event.targetInfo.parentFrameId) {
+        frame = this._page.frameManager.frameAttached(targetId, event.targetInfo.parentFrameId);
+      }
       if (!frame)
         return;
       this._page.frameManager.removeChildFramesRecursively(frame);
@@ -684,22 +683,14 @@ class FrameSession {
     this._crPage._networkManager.addSession(session, this._page.frameManager.frame(this._targetId) ?? void 0).catch(() => {
     });
     session._sendMayFail("Runtime.runIfWaitingForDebugger");
-    session._sendMayFail("Target.setAutoAttach", {
-      autoAttach: true,
-      waitForDebuggerOnStart: true,
-      flatten: true,
-      filter: [
-        { type: "worker" },
-        { type: "service_worker", exclude: !process.env.PW_EXPERIMENTAL_SERVICE_WORKER_NETWORK_EVENTS }
-      ]
-    });
+    session._sendMayFail("Target.setAutoAttach", { autoAttach: true, waitForDebuggerOnStart: true, flatten: true });
     session.on("Target.attachedToTarget", (event2) => this._onAttachedToTarget(event2));
     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(event2.type, args, (0, import_crProtocolHelper.toConsoleMessageLocation)(event2.stackTrace));
     });
-    session.on("Runtime.exceptionThrown", (exception) => this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, (0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails), this._page));
+    session.on("Runtime.exceptionThrown", (exception) => this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exception.exceptionDetails)));
   }
   _onDetachedFromTarget(event) {
     const workerSession = this._workerSessions.get(event.sessionId);
@@ -758,7 +749,7 @@ class FrameSession {
     ));
   }
   _handleException(exceptionDetails) {
-    this._page.emitOnContextOnceInitialized(import_browserContext.BrowserContext.Events.PageError, (0, import_crProtocolHelper.exceptionToError)(exceptionDetails), this._page);
+    this._page.addPageError((0, import_crProtocolHelper.exceptionToError)(exceptionDetails));
   }
   async _onTargetCrashed() {
     this._client._markAsCrashed();

package/lib/server/codegen/csharp.js

@@ -109,9 +109,13 @@ class CSharpLanguageGenerator {
         const options = (0, import_language.toClickOptionsForSourceCode)(action);
         if (!Object.entries(options).length)
           return `await ${subject}.${this._asLocator(action.selector)}.${method}Async();`;
-        const optionsString = formatObject(options, "    ", "Locator" + method + "Options");
+        const optionsString = formatObject(options, "    ");
         return `await ${subject}.${this._asLocator(action.selector)}.${method}Async(${optionsString});`;
       }
+      case "hover": {
+        const optionsString = action.position ? formatObject({ position: action.position }, "    ") : "";
+        return `await ${subject}.${this._asLocator(action.selector)}.HoverAsync(${optionsString});`;
+      }
       case "check":
         return `await ${subject}.${this._asLocator(action.selector)}.CheckAsync();`;
       case "uncheck":
@@ -159,11 +163,11 @@ class CSharpLanguageGenerator {
       using System.Threading.Tasks;
 
       using var playwright = await Playwright.CreateAsync();
-      await using var browser = await playwright.${toPascal(options.browserName)}.LaunchAsync(${formatObject(options.launchOptions, "    ", "BrowserTypeLaunchOptions")});
+      await using var browser = await playwright.${toPascal(options.browserName)}.LaunchAsync(${formatObject(options.launchOptions, "    ")});
       var context = await browser.NewContextAsync(${formatContextOptions(options.contextOptions, options.deviceName)});`);
     if (options.contextOptions.recordHar) {
       const url = options.contextOptions.recordHar.urlFilter;
-      formatter.add(`      await context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ", "BrowserContextRouteFromHAROptions")}` : ""});`);
+      formatter.add(`      await context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ")}` : ""});`);
     }
     formatter.newLine();
     return formatter.format();
@@ -191,14 +195,14 @@ class CSharpLanguageGenerator {
     {`);
     if (options.contextOptions.recordHar) {
       const url = options.contextOptions.recordHar.urlFilter;
-      formatter.add(`    await Context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ", "BrowserContextRouteFromHAROptions")}` : ""});`);
+      formatter.add(`    await Context.RouteFromHARAsync(${quote(options.contextOptions.recordHar.path)}${url ? `, ${formatObject({ url }, "    ")}` : ""});`);
     }
     return formatter.format();
   }
   generateFooter(saveStorage) {
     const offset = this._mode === "library" ? "" : "        ";
     let storageStateLine = saveStorage ? `
-${offset}await context.StorageStateAsync(new BrowserContextStorageStateOptions
+${offset}await context.StorageStateAsync(new()
 ${offset}{
 ${offset}    Path = ${quote(saveStorage)}
 ${offset}});
@@ -212,8 +216,8 @@ ${offset}});
 }
 function formatObject(value, indent = "    ", name = "") {
   if (typeof value === "string") {
-    if (["permissions", "colorScheme", "modifiers", "button", "recordHarContent", "recordHarMode", "serviceWorkers"].includes(name))
-      return `${getClassName(name)}.${toPascal(value)}`;
+    if (["colorScheme", "modifiers", "button", "recordHarContent", "recordHarMode", "serviceWorkers"].includes(name))
+      return `${getEnumName(name)}.${toPascal(value)}`;
     return quote(value);
   }
   if (Array.isArray(value))
@@ -221,35 +225,24 @@ function formatObject(value, indent = "    ", name = "") {
   if (typeof value === "object") {
     const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
     if (!keys.length)
-      return name ? `new ${getClassName(name)}` : "";
+      return `new()`;
     const tokens = [];
     for (const key of keys) {
       const property = getPropertyName(key);
       tokens.push(`${property} = ${formatObject(value[key], indent, key)},`);
     }
-    if (name)
-      return `new ${getClassName(name)}
+    return `new()
 {
 ${indent}${tokens.join(`
 ${indent}`)}
-${indent}}`;
-    return `{
-${indent}${tokens.join(`
-${indent}`)}
 ${indent}}`;
   }
   if (name === "latitude" || name === "longitude")
     return String(value) + "m";
   return String(value);
 }
-function getClassName(value) {
+function getEnumName(value) {
   switch (value) {
-    case "viewport":
-      return "ViewportSize";
-    case "proxy":
-      return "ProxySettings";
-    case "permissions":
-      return "ContextPermission";
     case "modifiers":
       return "KeyboardModifier";
     case "button":
@@ -278,18 +271,18 @@ function toPascal(value) {
   return value[0].toUpperCase() + value.slice(1);
 }
 function formatContextOptions(contextOptions, deviceName) {
-  let options = { ...contextOptions };
+  const options = { ...contextOptions };
   delete options.recordHar;
   const device = deviceName && import_deviceDescriptors.deviceDescriptors[deviceName];
   if (!device) {
     if (!Object.entries(options).length)
       return "";
-    return formatObject(options, "    ", "BrowserNewContextOptions");
+    return formatObject(options, "    ");
   }
-  options = (0, import_language.sanitizeDeviceOptions)(device, options);
-  if (!Object.entries(options).length)
+  if (!Object.entries((0, import_language.sanitizeDeviceOptions)(device, options)).length)
     return `playwright.Devices[${quote(deviceName)}]`;
-  return formatObject(options, "    ", `BrowserNewContextOptions(playwright.Devices[${quote(deviceName)}])`);
+  delete options["defaultBrowserType"];
+  return formatObject(options, "    ");
 }
 class CSharpFormatter {
   constructor(offset = 0) {

package/lib/server/codegen/java.js

@@ -91,6 +91,10 @@ class JavaLanguageGenerator {
         const optionsText = formatClickOptions(options);
         return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.${method}(${optionsText});`;
       }
+      case "hover": {
+        const optionsText = action.position ? `new Locator.HoverOptions().setPosition(${action.position.x}, ${action.position.y})` : "";
+        return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.hover(${optionsText});`;
+      }
       case "check":
         return `${subject}.${this._asLocator(action.selector, inFrameLocator)}.check();`;
       case "uncheck":

package/lib/server/codegen/javascript.js

@@ -81,6 +81,8 @@ class JavaScriptLanguageGenerator {
         const optionsString = formatOptions(options, false);
         return `await ${subject}.${this._asLocator(action.selector)}.${method}(${optionsString});`;
       }
+      case "hover":
+        return `await ${subject}.${this._asLocator(action.selector)}.hover(${formatOptions({ position: action.position }, false)});`;
       case "check":
         return `await ${subject}.${this._asLocator(action.selector)}.check();`;
       case "uncheck":
@@ -166,7 +168,7 @@ ${useText ? "\ntest.use(" + useText + ");\n" : ""}
   }
 }
 function formatOptions(value, hasArguments) {
-  const keys = Object.keys(value);
+  const keys = Object.keys(value).filter((key) => value[key] !== void 0);
   if (!keys.length)
     return "";
   return (hasArguments ? ", " : "") + formatObject(value);

package/lib/server/codegen/python.js

@@ -83,6 +83,8 @@ class PythonLanguageGenerator {
         const optionsString = formatOptions(options, false);
         return `${subject}.${this._asLocator(action.selector)}.${method}(${optionsString})`;
       }
+      case "hover":
+        return `${subject}.${this._asLocator(action.selector)}.hover(${formatOptions({ position: action.position }, false)})`;
       case "check":
         return `${subject}.${this._asLocator(action.selector)}.check()`;
       case "uncheck":

package/lib/server/debugController.js

@@ -31,13 +31,9 @@ var import_locatorParser = require("../utils/isomorphic/locatorParser");
 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._generateAutoExpect = false;
     this._playwright = playwright;
@@ -58,28 +54,16 @@ class DebugController extends import_instrumentation.SdkObject {
     this.setReportStateChanged(false);
   }
   setReportStateChanged(enabled) {
-    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));
-        },
+    if (enabled && !this._trackHierarchyListener) {
+      this._trackHierarchyListener = {
+        onPageOpen: () => this._emitSnapshot(false),
         onPageClose: () => this._emitSnapshot(false)
       };
-      this._playwright.instrumentation.addListener(listener, null);
-      this._disposeListeners.add(() => this._playwright.instrumentation.removeListener(listener));
+      this._playwright.instrumentation.addListener(this._trackHierarchyListener, null);
       this._emitSnapshot(true);
-    } else {
-      for (const dispose of this._disposeListeners)
-        dispose();
-      this._disposeListeners.clear();
+    } else if (!enabled && this._trackHierarchyListener) {
+      this._playwright.instrumentation.removeListener(this._trackHierarchyListener);
+      this._trackHierarchyListener = void 0;
     }
   }
   async setRecorderMode(progress, params) {
@@ -137,19 +121,7 @@ class DebugController extends import_instrumentation.SdkObject {
     const pageCount = this._playwright.allPages().length;
     if (initial && !pageCount)
       return;
-    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()
-          }))
-        }))
-      }))
-    });
+    this.emit(DebugController.Events.StateChanged, { pageCount });
   }
   async _allRecorders() {
     const contexts = /* @__PURE__ */ new Set();