@checkly/playwright-core 1.51.17-beta.1 → 1.54.2-beta.0

package/lib/server/dispatchers/browserDispatcher.js

@@ -1,170 +1,118 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserDispatcher_exports = {};
+__export(browserDispatcher_exports, {
+  BrowserDispatcher: () => BrowserDispatcher
 });
-exports.ConnectedBrowserDispatcher = exports.BrowserDispatcher = void 0;
-var _browser = require("../browser");
-var _browserContextDispatcher = require("./browserContextDispatcher");
-var _cdpSessionDispatcher = require("./cdpSessionDispatcher");
-var _dispatcher = require("./dispatcher");
-var _browserContext = require("../browserContext");
-var _selectors = require("../selectors");
-var _artifactDispatcher = require("./artifactDispatcher");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class BrowserDispatcher extends _dispatcher.Dispatcher {
-  constructor(scope, browser) {
-    super(scope, browser, 'Browser', {
-      version: browser.version(),
-      name: browser.options.name
-    });
+module.exports = __toCommonJS(browserDispatcher_exports);
+var import_browser = require("../browser");
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_cdpSessionDispatcher = require("./cdpSessionDispatcher");
+var import_dispatcher = require("./dispatcher");
+var import_browserContext = require("../browserContext");
+var import_artifactDispatcher = require("./artifactDispatcher");
+class BrowserDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, browser, options = {}) {
+    super(scope, browser, "Browser", { version: browser.version(), name: browser.options.name });
     this._type_Browser = true;
-    this.addObjectListener(_browser.Browser.Events.Disconnected, () => this._didClose());
+    this._isolatedContexts = /* @__PURE__ */ new Set();
+    this._options = options;
+    if (!options.isolateContexts) {
+      this.addObjectListener(import_browser.Browser.Events.Context, (context) => this._dispatchEvent("context", { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, context) }));
+      this.addObjectListener(import_browser.Browser.Events.Disconnected, () => this._didClose());
+      if (browser._defaultContext)
+        this._dispatchEvent("context", { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, browser._defaultContext) });
+      for (const context of browser.contexts())
+        this._dispatchEvent("context", { context: import_browserContextDispatcher.BrowserContextDispatcher.from(this, context) });
+    }
   }
   _didClose() {
-    this._dispatchEvent('close');
+    this._dispatchEvent("close");
     this._dispose();
   }
-  async newContext(params, metadata) {
-    const context = await this._object.newContext(metadata, params);
-    return {
-      context: new _browserContextDispatcher.BrowserContextDispatcher(this, context)
-    };
-  }
-  async newContextForReuse(params, metadata) {
-    return await newContextForReuse(this._object, this, params, null, metadata);
-  }
-  async stopPendingOperations(params, metadata) {
-    await this._object.stopPendingOperations(params.reason);
-  }
-  async close(params, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async newContext(params, progress) {
+    if (!this._options.isolateContexts) {
+      const context2 = await this._object.newContext(progress, params);
+      const contextDispatcher2 = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context2);
+      return { context: contextDispatcher2 };
+    }
+    if (params.recordVideo)
+      params.recordVideo.dir = this._object.options.artifactsDir;
+    const context = await this._object.newContext(progress, params);
+    this._isolatedContexts.add(context);
+    context.on(import_browserContext.BrowserContext.Events.Close, () => this._isolatedContexts.delete(context));
+    const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context);
+    this._dispatchEvent("context", { context: contextDispatcher });
+    return { context: contextDispatcher };
+  }
+  async newContextForReuse(params, progress) {
+    const context = await this._object.newContextForReuse(progress, params);
+    const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(this, context);
+    this._dispatchEvent("context", { context: contextDispatcher });
+    return { context: contextDispatcher };
+  }
+  async disconnectFromReusedContext(params, progress) {
+    const context = this._object.contextForReuse();
+    const contextDispatcher = context ? this.connection.existingDispatcher(context) : void 0;
+    if (contextDispatcher) {
+      await contextDispatcher.stopPendingOperations(new Error(params.reason));
+      contextDispatcher._dispose();
+    }
+  }
+  async close(params, progress) {
+    if (this._options.ignoreStopAndKill)
+      return;
+    progress.metadata.potentiallyClosesScope = true;
     await this._object.close(params);
   }
-  async killForTests(_, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async killForTests(params, progress) {
+    if (this._options.ignoreStopAndKill)
+      return;
+    progress.metadata.potentiallyClosesScope = true;
     await this._object.killForTests();
   }
   async defaultUserAgentForTest() {
-    return {
-      userAgent: this._object.userAgent()
-    };
+    return { userAgent: this._object.userAgent() };
   }
-  async newBrowserCDPSession() {
-    if (!this._object.options.isChromium) throw new Error(`CDP session is only available in Chromium`);
+  async newBrowserCDPSession(params, progress) {
+    if (!this._object.options.isChromium)
+      throw new Error(`CDP session is only available in Chromium`);
     const crBrowser = this._object;
-    return {
-      session: new _cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession())
-    };
+    return { session: new import_cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession()) };
   }
-  async startTracing(params) {
-    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+  async startTracing(params, progress) {
+    if (!this._object.options.isChromium)
+      throw new Error(`Tracing is only available in Chromium`);
     const crBrowser = this._object;
-    await crBrowser.startTracing(params.page ? params.page._object : undefined, params);
+    await crBrowser.startTracing(params.page ? params.page._object : void 0, params);
   }
-  async stopTracing() {
-    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
+  async stopTracing(params, progress) {
+    if (!this._object.options.isChromium)
+      throw new Error(`Tracing is only available in Chromium`);
     const crBrowser = this._object;
-    return {
-      artifact: _artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing())
-    };
-  }
-}
-
-// This class implements multiplexing browser dispatchers over a single Browser instance.
-exports.BrowserDispatcher = BrowserDispatcher;
-class ConnectedBrowserDispatcher extends _dispatcher.Dispatcher {
-  constructor(scope, browser) {
-    super(scope, browser, 'Browser', {
-      version: browser.version(),
-      name: browser.options.name
-    });
-    // When we have a remotely-connected browser, each client gets a fresh Selector instance,
-    // so that two clients do not interfere between each other.
-    this._type_Browser = true;
-    this._contexts = new Set();
-    this.selectors = void 0;
-    this.selectors = new _selectors.Selectors();
-  }
-  async newContext(params, metadata) {
-    if (params.recordVideo) params.recordVideo.dir = this._object.options.artifactsDir;
-    const context = await this._object.newContext(metadata, params);
-    this._contexts.add(context);
-    context.setSelectors(this.selectors);
-    context.on(_browserContext.BrowserContext.Events.Close, () => this._contexts.delete(context));
-    return {
-      context: new _browserContextDispatcher.BrowserContextDispatcher(this, context)
-    };
-  }
-  async newContextForReuse(params, metadata) {
-    return await newContextForReuse(this._object, this, params, this.selectors, metadata);
-  }
-  async stopPendingOperations(params, metadata) {
-    await this._object.stopPendingOperations(params.reason);
-  }
-  async close() {
-    // Client should not send us Browser.close.
-  }
-  async killForTests() {
-    // Client should not send us Browser.killForTests.
-  }
-  async defaultUserAgentForTest() {
-    throw new Error('Client should not send us Browser.defaultUserAgentForTest');
-  }
-  async newBrowserCDPSession() {
-    if (!this._object.options.isChromium) throw new Error(`CDP session is only available in Chromium`);
-    const crBrowser = this._object;
-    return {
-      session: new _cdpSessionDispatcher.CDPSessionDispatcher(this, await crBrowser.newBrowserCDPSession())
-    };
-  }
-  async startTracing(params) {
-    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    await crBrowser.startTracing(params.page ? params.page._object : undefined, params);
-  }
-  async stopTracing() {
-    if (!this._object.options.isChromium) throw new Error(`Tracing is only available in Chromium`);
-    const crBrowser = this._object;
-    return {
-      artifact: _artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing())
-    };
+    return { artifact: import_artifactDispatcher.ArtifactDispatcher.from(this, await crBrowser.stopTracing()) };
   }
   async cleanupContexts() {
-    await Promise.all(Array.from(this._contexts).map(context => context.close({
-      reason: 'Global context cleanup (connection terminated)'
-    })));
+    await Promise.all(Array.from(this._isolatedContexts).map((context) => context.close({ reason: "Global context cleanup (connection terminated)" })));
   }
 }
-exports.ConnectedBrowserDispatcher = ConnectedBrowserDispatcher;
-async function newContextForReuse(browser, scope, params, selectors, metadata) {
-  const {
-    context,
-    needsReset
-  } = await browser.newContextForReuse(params, metadata);
-  if (needsReset) {
-    const oldContextDispatcher = (0, _dispatcher.existingDispatcher)(context);
-    if (oldContextDispatcher) oldContextDispatcher._dispose();
-    await context.resetForReuse(metadata, params);
-  }
-  if (selectors) context.setSelectors(selectors);
-  const contextDispatcher = new _browserContextDispatcher.BrowserContextDispatcher(scope, context);
-  return {
-    context: contextDispatcher
-  };
-}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserDispatcher
+});

package/lib/server/dispatchers/browserTypeDispatcher.js

@@ -1,55 +1,64 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browserTypeDispatcher_exports = {};
+__export(browserTypeDispatcher_exports, {
+  BrowserTypeDispatcher: () => BrowserTypeDispatcher
 });
-exports.BrowserTypeDispatcher = void 0;
-var _browserContextDispatcher = require("./browserContextDispatcher");
-var _browserDispatcher = require("./browserDispatcher");
-var _dispatcher = require("./dispatcher");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class BrowserTypeDispatcher extends _dispatcher.Dispatcher {
-  constructor(scope, browserType) {
-    super(scope, browserType, 'BrowserType', {
+module.exports = __toCommonJS(browserTypeDispatcher_exports);
+var import_browserContextDispatcher = require("./browserContextDispatcher");
+var import_browserDispatcher = require("./browserDispatcher");
+var import_dispatcher = require("./dispatcher");
+class BrowserTypeDispatcher extends import_dispatcher.Dispatcher {
+  constructor(scope, browserType, denyLaunch) {
+    super(scope, browserType, "BrowserType", {
       executablePath: browserType.executablePath(),
       name: browserType.name()
     });
     this._type_BrowserType = true;
+    this._denyLaunch = denyLaunch;
   }
-  async launch(params, metadata) {
-    const browser = await this._object.launch(metadata, params);
-    return {
-      browser: new _browserDispatcher.BrowserDispatcher(this, browser)
-    };
+  async launch(params, progress) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
+    const browser = await this._object.launch(progress, params);
+    return { browser: new import_browserDispatcher.BrowserDispatcher(this, browser) };
   }
-  async launchPersistentContext(params, metadata) {
-    const browserContext = await this._object.launchPersistentContext(metadata, params.userDataDir, params);
-    return {
-      context: new _browserContextDispatcher.BrowserContextDispatcher(this, browserContext)
-    };
+  async launchPersistentContext(params, progress) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
+    const browserContext = await this._object.launchPersistentContext(progress, params.userDataDir, params);
+    const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browserContext._browser);
+    const contextDispatcher = import_browserContextDispatcher.BrowserContextDispatcher.from(browserDispatcher, browserContext);
+    return { browser: browserDispatcher, context: contextDispatcher };
   }
-  async connectOverCDP(params, metadata) {
-    const browser = await this._object.connectOverCDP(metadata, params.endpointURL, params, params.timeout);
-    const browserDispatcher = new _browserDispatcher.BrowserDispatcher(this, browser);
+  async connectOverCDP(params, progress) {
+    if (this._denyLaunch)
+      throw new Error(`Launching more browsers is not allowed.`);
+    const browser = await this._object.connectOverCDP(progress, params.endpointURL, params);
+    const browserDispatcher = new import_browserDispatcher.BrowserDispatcher(this, browser);
     return {
       browser: browserDispatcher,
-      defaultContext: browser._defaultContext ? new _browserContextDispatcher.BrowserContextDispatcher(browserDispatcher, browser._defaultContext) : undefined
+      defaultContext: browser._defaultContext ? import_browserContextDispatcher.BrowserContextDispatcher.from(browserDispatcher, browser._defaultContext) : void 0
     };
   }
 }
-exports.BrowserTypeDispatcher = BrowserTypeDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserTypeDispatcher
+});

package/lib/server/dispatchers/cdpSessionDispatcher.js

@@ -1,48 +1,44 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cdpSessionDispatcher_exports = {};
+__export(cdpSessionDispatcher_exports, {
+  CDPSessionDispatcher: () => CDPSessionDispatcher
 });
-exports.CDPSessionDispatcher = void 0;
-var _dispatcher = require("./dispatcher");
-var _crConnection = require("../chromium/crConnection");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class CDPSessionDispatcher extends _dispatcher.Dispatcher {
+module.exports = __toCommonJS(cdpSessionDispatcher_exports);
+var import_dispatcher = require("./dispatcher");
+var import_crConnection = require("../chromium/crConnection");
+class CDPSessionDispatcher extends import_dispatcher.Dispatcher {
   constructor(scope, cdpSession) {
-    super(scope, cdpSession, 'CDPSession', {});
+    super(scope, cdpSession, "CDPSession", {});
     this._type_CDPSession = true;
-    this.addObjectListener(_crConnection.CDPSession.Events.Event, ({
-      method,
-      params
-    }) => this._dispatchEvent('event', {
-      method,
-      params
-    }));
-    this.addObjectListener(_crConnection.CDPSession.Events.Closed, () => this._dispose());
+    this.addObjectListener(import_crConnection.CDPSession.Events.Event, ({ method, params }) => this._dispatchEvent("event", { method, params }));
+    this.addObjectListener(import_crConnection.CDPSession.Events.Closed, () => this._dispose());
   }
-  async send(params) {
-    return {
-      result: await this._object.send(params.method, params.params)
-    };
+  async send(params, progress) {
+    return { result: await progress.race(this._object.send(params.method, params.params)) };
   }
-  async detach(_, metadata) {
-    metadata.potentiallyClosesScope = true;
+  async detach(_, progress) {
+    progress.metadata.potentiallyClosesScope = true;
     await this._object.detach();
   }
 }
-exports.CDPSessionDispatcher = CDPSessionDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPSessionDispatcher
+});

package/lib/server/dispatchers/debugControllerDispatcher.js

@@ -1,105 +1,87 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var debugControllerDispatcher_exports = {};
+__export(debugControllerDispatcher_exports, {
+  DebugControllerDispatcher: () => DebugControllerDispatcher
 });
-exports.DebugControllerDispatcher = void 0;
-var _utils = require("../../utils");
-var _debugController = require("../debugController");
-var _dispatcher = require("./dispatcher");
-/**
- * Copyright (c) Microsoft Corporation.
- *
- * Licensed under the Apache License, Version 2.0 (the 'License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-class DebugControllerDispatcher extends _dispatcher.Dispatcher {
+module.exports = __toCommonJS(debugControllerDispatcher_exports);
+var import_utils = require("../../utils");
+var import_debugController = require("../debugController");
+var import_dispatcher = require("./dispatcher");
+class DebugControllerDispatcher extends import_dispatcher.Dispatcher {
   constructor(connection, debugController) {
-    super(connection, debugController, 'DebugController', {});
-    this._type_DebugController = void 0;
-    this._listeners = void 0;
+    super(connection, debugController, "DebugController", {});
     this._type_DebugController = true;
-    this._listeners = [_utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.StateChanged, params => {
-      this._dispatchEvent('stateChanged', params);
-    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.InspectRequested, ({
-      selector,
-      locator,
-      ariaSnapshot
-    }) => {
-      this._dispatchEvent('inspectRequested', {
-        selector,
-        locator,
-        ariaSnapshot
-      });
-    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.SourceChanged, ({
-      text,
-      header,
-      footer,
-      actions
-    }) => {
-      this._dispatchEvent('sourceChanged', {
-        text,
-        header,
-        footer,
-        actions
-      });
-    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.Paused, ({
-      paused
-    }) => {
-      this._dispatchEvent('paused', {
-        paused
-      });
-    }), _utils.eventsHelper.addEventListener(this._object, _debugController.DebugController.Events.SetModeRequested, ({
-      mode
-    }) => {
-      this._dispatchEvent('setModeRequested', {
-        mode
-      });
-    })];
+    this._listeners = [
+      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.StateChanged, (params) => {
+        this._dispatchEvent("stateChanged", params);
+      }),
+      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.InspectRequested, ({ selector, locator, ariaSnapshot }) => {
+        this._dispatchEvent("inspectRequested", { selector, locator, ariaSnapshot });
+      }),
+      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.SourceChanged, ({ text, header, footer, actions }) => {
+        this._dispatchEvent("sourceChanged", { text, header, footer, actions });
+      }),
+      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.Paused, ({ paused }) => {
+        this._dispatchEvent("paused", { paused });
+      }),
+      import_utils.eventsHelper.addEventListener(this._object, import_debugController.DebugController.Events.SetModeRequested, ({ mode }) => {
+        this._dispatchEvent("setModeRequested", { mode });
+      })
+    ];
   }
-  async initialize(params) {
+  async initialize(params, progress) {
     this._object.initialize(params.codegenId, params.sdkLanguage);
   }
-  async setReportStateChanged(params) {
+  async setReportStateChanged(params, progress) {
     this._object.setReportStateChanged(params.enabled);
   }
-  async resetForReuse() {
-    await this._object.resetForReuse();
+  async resetForReuse(params, progress) {
+    await this._object.resetForReuse(progress);
   }
-  async navigate(params) {
-    await this._object.navigate(params.url);
+  async navigate(params, progress) {
+    await this._object.navigate(progress, params.url);
   }
-  async setRecorderMode(params) {
-    await this._object.setRecorderMode(params);
+  async setRecorderMode(params, progress) {
+    await this._object.setRecorderMode(progress, params);
   }
-  async highlight(params) {
-    await this._object.highlight(params);
+  async highlight(params, progress) {
+    await this._object.highlight(progress, params);
   }
-  async hideHighlight() {
-    await this._object.hideHighlight();
+  async hideHighlight(params, progress) {
+    await this._object.hideHighlight(progress);
   }
-  async resume() {
-    await this._object.resume();
+  async resume(params, progress) {
+    await this._object.resume(progress);
   }
-  async kill() {
-    await this._object.kill();
+  async kill(params, progress) {
+    this._object.kill();
   }
-  async closeAllBrowsers() {
+  async closeAllBrowsers(params, progress) {
     await this._object.closeAllBrowsers();
   }
   _onDispose() {
-    _utils.eventsHelper.removeEventListeners(this._listeners);
+    import_utils.eventsHelper.removeEventListeners(this._listeners);
     this._object.dispose();
   }
 }
-exports.DebugControllerDispatcher = DebugControllerDispatcher;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebugControllerDispatcher
+});