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

package/lib/server/dispatchers/dispatcher.js

@@ -1,255 +1,235 @@
 "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 dispatcher_exports = {};
+__export(dispatcher_exports, {
+  Dispatcher: () => Dispatcher,
+  DispatcherConnection: () => DispatcherConnection,
+  RootDispatcher: () => RootDispatcher,
+  setMaxDispatchersForTest: () => setMaxDispatchersForTest
 });
-exports.dispatcherSymbol = exports.RootDispatcher = exports.DispatcherConnection = exports.Dispatcher = void 0;
-exports.existingDispatcher = existingDispatcher;
-exports.setMaxDispatchersForTest = setMaxDispatchersForTest;
-var _events = require("events");
-var _eventsHelper = require("../utils/eventsHelper");
-var _validator = require("../../protocol/validator");
-var _utils = require("../../utils");
-var _debug = require("../utils/debug");
-var _errors = require("../errors");
-var _instrumentation = require("../instrumentation");
-var _protocolError = require("../protocolError");
-var _callLog = require("../callLog");
-/**
- * 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.
- */
-
-const dispatcherSymbol = exports.dispatcherSymbol = Symbol('dispatcher');
-const metadataValidator = (0, _validator.createMetadataValidator)();
-function existingDispatcher(object) {
-  return object[dispatcherSymbol];
-}
+module.exports = __toCommonJS(dispatcher_exports);
+var import_events = require("events");
+var import_eventsHelper = require("../utils/eventsHelper");
+var import_validator = require("../../protocol/validator");
+var import_utils = require("../../utils");
+var import_debug = require("../utils/debug");
+var import_errors = require("../errors");
+var import_instrumentation = require("../instrumentation");
+var import_protocolError = require("../protocolError");
+var import_callLog = require("../callLog");
+var import_protocolMetainfo = require("../../utils/isomorphic/protocolMetainfo");
+var import_progress = require("../progress");
+const metadataValidator = (0, import_validator.createMetadataValidator)();
 let maxDispatchersOverride;
 function setMaxDispatchersForTest(value) {
   maxDispatchersOverride = value;
 }
 function maxDispatchersForBucket(gcBucket) {
-  var _ref;
-  return (_ref = maxDispatchersOverride !== null && maxDispatchersOverride !== void 0 ? maxDispatchersOverride : {
-    'JSHandle': 100000,
-    'ElementHandle': 100000
-  }[gcBucket]) !== null && _ref !== void 0 ? _ref : 10000;
+  return maxDispatchersOverride ?? {
+    "JSHandle": 1e5,
+    "ElementHandle": 1e5
+  }[gcBucket] ?? 1e4;
 }
-class Dispatcher extends _events.EventEmitter {
+class Dispatcher extends import_events.EventEmitter {
   constructor(parent, object, type, initializer, gcBucket) {
     super();
-    this._connection = void 0;
-    // Parent is always "isScope".
-    this._parent = void 0;
-    // Only "isScope" channel owners have registered dispatchers inside.
-    this._dispatchers = new Map();
+    this._dispatchers = /* @__PURE__ */ new Map();
     this._disposed = false;
     this._eventListeners = [];
-    this._guid = void 0;
-    this._type = void 0;
-    this._gcBucket = void 0;
-    this._object = void 0;
-    this._openScope = new _utils.LongStandingScope();
-    this._connection = parent instanceof DispatcherConnection ? parent : parent._connection;
-    this._parent = parent instanceof DispatcherConnection ? undefined : parent;
+    this._activeProgressControllers = /* @__PURE__ */ new Set();
+    this.connection = parent instanceof DispatcherConnection ? parent : parent.connection;
+    this._parent = parent instanceof DispatcherConnection ? void 0 : parent;
     const guid = object.guid;
     this._guid = guid;
     this._type = type;
     this._object = object;
-    this._gcBucket = gcBucket !== null && gcBucket !== void 0 ? gcBucket : type;
-    object[dispatcherSymbol] = this;
-    this._connection.registerDispatcher(this);
+    this._gcBucket = gcBucket ?? type;
+    this.connection.registerDispatcher(this);
     if (this._parent) {
-      (0, _utils.assert)(!this._parent._dispatchers.has(guid));
+      (0, import_utils.assert)(!this._parent._dispatchers.has(guid));
       this._parent._dispatchers.set(guid, this);
     }
-    if (this._parent) this._connection.sendCreate(this._parent, type, guid, initializer);
-    this._connection.maybeDisposeStaleDispatchers(this._gcBucket);
+    if (this._parent)
+      this.connection.sendCreate(this._parent, type, guid, initializer);
+    this.connection.maybeDisposeStaleDispatchers(this._gcBucket);
   }
   parentScope() {
     return this._parent;
   }
   addObjectListener(eventName, handler) {
-    this._eventListeners.push(_eventsHelper.eventsHelper.addEventListener(this._object, eventName, handler));
+    this._eventListeners.push(import_eventsHelper.eventsHelper.addEventListener(this._object, eventName, handler));
   }
   adopt(child) {
-    if (child._parent === this) return;
+    if (child._parent === this)
+      return;
     const oldParent = child._parent;
     oldParent._dispatchers.delete(child._guid);
     this._dispatchers.set(child._guid, child);
     child._parent = this;
-    this._connection.sendAdopt(this, child);
+    this.connection.sendAdopt(this, child);
   }
-  async _handleCommand(callMetadata, method, validParams) {
-    const commandPromise = this[method](validParams, callMetadata);
+  async _runCommand(callMetadata, method, validParams) {
+    const controller = new import_progress.ProgressController(callMetadata, this._object);
+    this._activeProgressControllers.add(controller);
     try {
-      return await this._openScope.race(commandPromise);
-    } catch (e) {
-      if (callMetadata.potentiallyClosesScope && (0, _errors.isTargetClosedError)(e)) return await commandPromise;
-      throw e;
+      return await controller.run((progress) => this[method](validParams, progress), validParams?.timeout);
+    } finally {
+      this._activeProgressControllers.delete(controller);
     }
   }
   _dispatchEvent(method, params) {
     if (this._disposed) {
-      if ((0, _debug.isUnderTest)()) throw new Error(`${this._guid} is sending "${String(method)}" event after being disposed`);
-      // Just ignore this event outside of tests.
+      if ((0, import_debug.isUnderTest)())
+        throw new Error(`${this._guid} is sending "${String(method)}" event after being disposed`);
       return;
     }
-    this._connection.sendEvent(this, method, params);
+    this.connection.sendEvent(this, method, params);
   }
   _dispose(reason) {
-    this._disposeRecursively(new _errors.TargetClosedError());
-    this._connection.sendDispose(this, reason);
+    this._disposeRecursively(new import_errors.TargetClosedError());
+    this.connection.sendDispose(this, reason);
+  }
+  _onDispose() {
+  }
+  async stopPendingOperations(error) {
+    const controllers = [];
+    const collect = (dispatcher) => {
+      controllers.push(...dispatcher._activeProgressControllers);
+      for (const child of [...dispatcher._dispatchers.values()])
+        collect(child);
+    };
+    collect(this);
+    await Promise.all(controllers.map((controller) => controller.abort(error)));
   }
-  _onDispose() {}
   _disposeRecursively(error) {
-    var _this$_parent;
-    (0, _utils.assert)(!this._disposed, `${this._guid} is disposed more than once`);
+    (0, import_utils.assert)(!this._disposed, `${this._guid} is disposed more than once`);
+    for (const controller of this._activeProgressControllers) {
+      if (!controller.metadata.potentiallyClosesScope)
+        controller.abort(error).catch(() => {
+        });
+    }
     this._onDispose();
     this._disposed = true;
-    _eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
-
-    // Clean up from parent and connection.
-    (_this$_parent = this._parent) === null || _this$_parent === void 0 || _this$_parent._dispatchers.delete(this._guid);
-    const list = this._connection._dispatchersByBucket.get(this._gcBucket);
-    list === null || list === void 0 || list.delete(this._guid);
-    this._connection._dispatchers.delete(this._guid);
-
-    // Dispose all children.
-    for (const dispatcher of [...this._dispatchers.values()]) dispatcher._disposeRecursively(error);
+    import_eventsHelper.eventsHelper.removeEventListeners(this._eventListeners);
+    this._parent?._dispatchers.delete(this._guid);
+    const list = this.connection._dispatchersByBucket.get(this._gcBucket);
+    list?.delete(this._guid);
+    this.connection._dispatcherByGuid.delete(this._guid);
+    this.connection._dispatcherByObject.delete(this._object);
+    for (const dispatcher of [...this._dispatchers.values()])
+      dispatcher._disposeRecursively(error);
     this._dispatchers.clear();
-    delete this._object[dispatcherSymbol];
-    this._openScope.close(error);
   }
   _debugScopeState() {
     return {
       _guid: this._guid,
-      objects: Array.from(this._dispatchers.values()).map(o => o._debugScopeState())
+      objects: Array.from(this._dispatchers.values()).map((o) => o._debugScopeState())
     };
   }
   async waitForEventInfo() {
-    // Instrumentation takes care of this.
   }
 }
-exports.Dispatcher = Dispatcher;
 class RootDispatcher extends Dispatcher {
   constructor(connection, createPlaywright) {
-    super(connection, {
-      guid: ''
-    }, 'Root', {});
-    this._initialized = false;
+    super(connection, (0, import_instrumentation.createRootSdkObject)(), "Root", {});
     this.createPlaywright = createPlaywright;
+    this._initialized = false;
   }
-  async initialize(params) {
-    (0, _utils.assert)(this.createPlaywright);
-    (0, _utils.assert)(!this._initialized);
+  async initialize(params, progress) {
+    (0, import_utils.assert)(this.createPlaywright);
+    (0, import_utils.assert)(!this._initialized);
     this._initialized = true;
     return {
       playwright: await this.createPlaywright(this, params)
     };
   }
 }
-exports.RootDispatcher = RootDispatcher;
 class DispatcherConnection {
   constructor(isLocal) {
-    this._dispatchers = new Map();
-    this._dispatchersByBucket = new Map();
-    this.onmessage = message => {};
-    this._waitOperations = new Map();
-    this._isLocal = void 0;
+    this._dispatcherByGuid = /* @__PURE__ */ new Map();
+    this._dispatcherByObject = /* @__PURE__ */ new Map();
+    this._dispatchersByBucket = /* @__PURE__ */ new Map();
+    this.onmessage = (message) => {
+    };
+    this._waitOperations = /* @__PURE__ */ new Map();
     this._isLocal = !!isLocal;
   }
   sendEvent(dispatcher, event, params) {
-    const validator = (0, _validator.findValidator)(dispatcher._type, event, 'Event');
-    params = validator(params, '', this._validatorToWireContext());
-    this.onmessage({
-      guid: dispatcher._guid,
-      method: event,
-      params
-    });
+    const validator = (0, import_validator.findValidator)(dispatcher._type, event, "Event");
+    params = validator(params, "", this._validatorToWireContext());
+    this.onmessage({ guid: dispatcher._guid, method: event, params });
   }
   sendCreate(parent, type, guid, initializer) {
-    const validator = (0, _validator.findValidator)(type, '', 'Initializer');
-    initializer = validator(initializer, '', this._validatorToWireContext());
-    this.onmessage({
-      guid: parent._guid,
-      method: '__create__',
-      params: {
-        type,
-        initializer,
-        guid
-      }
-    });
+    const validator = (0, import_validator.findValidator)(type, "", "Initializer");
+    initializer = validator(initializer, "", this._validatorToWireContext());
+    this.onmessage({ guid: parent._guid, method: "__create__", params: { type, initializer, guid } });
   }
   sendAdopt(parent, dispatcher) {
-    this.onmessage({
-      guid: parent._guid,
-      method: '__adopt__',
-      params: {
-        guid: dispatcher._guid
-      }
-    });
+    this.onmessage({ guid: parent._guid, method: "__adopt__", params: { guid: dispatcher._guid } });
   }
   sendDispose(dispatcher, reason) {
-    this.onmessage({
-      guid: dispatcher._guid,
-      method: '__dispose__',
-      params: {
-        reason
-      }
-    });
+    this.onmessage({ guid: dispatcher._guid, method: "__dispose__", params: { reason } });
   }
   _validatorToWireContext() {
     return {
       tChannelImpl: this._tChannelImplToWire.bind(this),
-      binary: this._isLocal ? 'buffer' : 'toBase64',
-      isUnderTest: _debug.isUnderTest
+      binary: this._isLocal ? "buffer" : "toBase64",
+      isUnderTest: import_debug.isUnderTest
     };
   }
   _validatorFromWireContext() {
     return {
       tChannelImpl: this._tChannelImplFromWire.bind(this),
-      binary: this._isLocal ? 'buffer' : 'fromBase64',
-      isUnderTest: _debug.isUnderTest
+      binary: this._isLocal ? "buffer" : "fromBase64",
+      isUnderTest: import_debug.isUnderTest
     };
   }
   _tChannelImplFromWire(names, arg, path, context) {
-    if (arg && typeof arg === 'object' && typeof arg.guid === 'string') {
+    if (arg && typeof arg === "object" && typeof arg.guid === "string") {
       const guid = arg.guid;
-      const dispatcher = this._dispatchers.get(guid);
-      if (!dispatcher) throw new _validator.ValidationError(`${path}: no object with guid ${guid}`);
-      if (names !== '*' && !names.includes(dispatcher._type)) throw new _validator.ValidationError(`${path}: object with guid ${guid} has type ${dispatcher._type}, expected ${names.toString()}`);
+      const dispatcher = this._dispatcherByGuid.get(guid);
+      if (!dispatcher)
+        throw new import_validator.ValidationError(`${path}: no object with guid ${guid}`);
+      if (names !== "*" && !names.includes(dispatcher._type))
+        throw new import_validator.ValidationError(`${path}: object with guid ${guid} has type ${dispatcher._type}, expected ${names.toString()}`);
       return dispatcher;
     }
-    throw new _validator.ValidationError(`${path}: expected guid for ${names.toString()}`);
+    throw new import_validator.ValidationError(`${path}: expected guid for ${names.toString()}`);
   }
   _tChannelImplToWire(names, arg, path, context) {
     if (arg instanceof Dispatcher) {
-      if (names !== '*' && !names.includes(arg._type)) throw new _validator.ValidationError(`${path}: dispatcher with guid ${arg._guid} has type ${arg._type}, expected ${names.toString()}`);
-      return {
-        guid: arg._guid
-      };
+      if (names !== "*" && !names.includes(arg._type))
+        throw new import_validator.ValidationError(`${path}: dispatcher with guid ${arg._guid} has type ${arg._type}, expected ${names.toString()}`);
+      return { guid: arg._guid };
     }
-    throw new _validator.ValidationError(`${path}: expected dispatcher ${names.toString()}`);
+    throw new import_validator.ValidationError(`${path}: expected dispatcher ${names.toString()}`);
+  }
+  existingDispatcher(object) {
+    return this._dispatcherByObject.get(object);
   }
   registerDispatcher(dispatcher) {
-    (0, _utils.assert)(!this._dispatchers.has(dispatcher._guid));
-    this._dispatchers.set(dispatcher._guid, dispatcher);
+    (0, import_utils.assert)(!this._dispatcherByGuid.has(dispatcher._guid));
+    this._dispatcherByGuid.set(dispatcher._guid, dispatcher);
+    this._dispatcherByObject.set(dispatcher._object, dispatcher);
     let list = this._dispatchersByBucket.get(dispatcher._gcBucket);
     if (!list) {
-      list = new Set();
+      list = /* @__PURE__ */ new Set();
       this._dispatchersByBucket.set(dispatcher._gcBucket, list);
     }
     list.add(dispatcher._guid);
@@ -257,141 +237,121 @@ class DispatcherConnection {
   maybeDisposeStaleDispatchers(gcBucket) {
     const maxDispatchers = maxDispatchersForBucket(gcBucket);
     const list = this._dispatchersByBucket.get(gcBucket);
-    if (!list || list.size <= maxDispatchers) return;
+    if (!list || list.size <= maxDispatchers)
+      return;
     const dispatchersArray = [...list];
     const disposeCount = maxDispatchers / 10 | 0;
     this._dispatchersByBucket.set(gcBucket, new Set(dispatchersArray.slice(disposeCount)));
     for (let i = 0; i < disposeCount; ++i) {
-      const d = this._dispatchers.get(dispatchersArray[i]);
-      if (!d) continue;
-      d._dispose('gc');
+      const d = this._dispatcherByGuid.get(dispatchersArray[i]);
+      if (!d)
+        continue;
+      d._dispose("gc");
     }
   }
   async dispatch(message) {
-    var _sdkObject$attributio, _sdkObject$attributio2, _params$info;
-    const {
-      id,
-      guid,
-      method,
-      params,
-      metadata
-    } = message;
-    const dispatcher = this._dispatchers.get(guid);
+    const { id, guid, method, params, metadata } = message;
+    const dispatcher = this._dispatcherByGuid.get(guid);
     if (!dispatcher) {
-      this.onmessage({
-        id,
-        error: (0, _errors.serializeError)(new _errors.TargetClosedError())
-      });
+      this.onmessage({ id, error: (0, import_errors.serializeError)(new import_errors.TargetClosedError()) });
       return;
     }
     let validParams;
     let validMetadata;
     try {
-      const validator = (0, _validator.findValidator)(dispatcher._type, method, 'Params');
+      const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Params");
       const validatorContext = this._validatorFromWireContext();
-      validParams = validator(params, '', validatorContext);
-      validMetadata = metadataValidator(metadata, '', validatorContext);
-      if (typeof dispatcher[method] !== 'function') throw new Error(`Mismatching dispatcher: "${dispatcher._type}" does not implement "${method}"`);
+      validParams = validator(params, "", validatorContext);
+      validMetadata = metadataValidator(metadata, "", validatorContext);
+      if (typeof dispatcher[method] !== "function")
+        throw new Error(`Mismatching dispatcher: "${dispatcher._type}" does not implement "${method}"`);
     } catch (e) {
-      this.onmessage({
-        id,
-        error: (0, _errors.serializeError)(e)
-      });
+      this.onmessage({ id, error: (0, import_errors.serializeError)(e) });
       return;
     }
-    const sdkObject = dispatcher._object instanceof _instrumentation.SdkObject ? dispatcher._object : undefined;
+    if (import_protocolMetainfo.methodMetainfo.get(dispatcher._type + "." + method)?.internal) {
+      validMetadata.internal = true;
+    }
+    const sdkObject = dispatcher._object;
     const callMetadata = {
       id: `call@${id}`,
       location: validMetadata.location,
-      apiName: validMetadata.apiName,
+      title: validMetadata.title,
       internal: validMetadata.internal,
       stepId: validMetadata.stepId,
-      objectId: sdkObject === null || sdkObject === void 0 ? void 0 : sdkObject.guid,
-      pageId: sdkObject === null || sdkObject === void 0 || (_sdkObject$attributio = sdkObject.attribution) === null || _sdkObject$attributio === void 0 || (_sdkObject$attributio = _sdkObject$attributio.page) === null || _sdkObject$attributio === void 0 ? void 0 : _sdkObject$attributio.guid,
-      frameId: sdkObject === null || sdkObject === void 0 || (_sdkObject$attributio2 = sdkObject.attribution) === null || _sdkObject$attributio2 === void 0 || (_sdkObject$attributio2 = _sdkObject$attributio2.frame) === null || _sdkObject$attributio2 === void 0 ? void 0 : _sdkObject$attributio2.guid,
-      startTime: (0, _utils.monotonicTime)(),
+      objectId: sdkObject.guid,
+      pageId: sdkObject.attribution?.page?.guid,
+      frameId: sdkObject.attribution?.frame?.guid,
+      startTime: (0, import_utils.monotonicTime)(),
       endTime: 0,
       type: dispatcher._type,
       method,
       params: params || {},
       log: []
     };
-    if (sdkObject && params !== null && params !== void 0 && (_params$info = params.info) !== null && _params$info !== void 0 && _params$info.waitId) {
-      // Process logs for waitForNavigation/waitForLoadState/etc.
+    if (params?.info?.waitId) {
       const info = params.info;
       switch (info.phase) {
-        case 'before':
-          {
-            this._waitOperations.set(info.waitId, callMetadata);
-            await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
-            this.onmessage({
-              id
-            });
-            return;
-          }
-        case 'log':
-          {
-            const originalMetadata = this._waitOperations.get(info.waitId);
-            originalMetadata.log.push(info.message);
-            sdkObject.instrumentation.onCallLog(sdkObject, originalMetadata, 'api', info.message);
-            this.onmessage({
-              id
-            });
-            return;
-          }
-        case 'after':
-          {
-            const originalMetadata = this._waitOperations.get(info.waitId);
-            originalMetadata.endTime = (0, _utils.monotonicTime)();
-            originalMetadata.error = info.error ? {
-              error: {
-                name: 'Error',
-                message: info.error
-              }
-            } : undefined;
-            this._waitOperations.delete(info.waitId);
-            await sdkObject.instrumentation.onAfterCall(sdkObject, originalMetadata);
-            this.onmessage({
-              id
-            });
-            return;
-          }
+        case "before": {
+          this._waitOperations.set(info.waitId, callMetadata);
+          await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
+          this.onmessage({ id });
+          return;
+        }
+        case "log": {
+          const originalMetadata = this._waitOperations.get(info.waitId);
+          originalMetadata.log.push(info.message);
+          sdkObject.instrumentation.onCallLog(sdkObject, originalMetadata, "api", info.message);
+          this.onmessage({ id });
+          return;
+        }
+        case "after": {
+          const originalMetadata = this._waitOperations.get(info.waitId);
+          originalMetadata.endTime = (0, import_utils.monotonicTime)();
+          originalMetadata.error = info.error ? { error: { name: "Error", message: info.error } } : void 0;
+          this._waitOperations.delete(info.waitId);
+          await sdkObject.instrumentation.onAfterCall(sdkObject, originalMetadata);
+          this.onmessage({ id });
+          return;
+        }
       }
     }
-    await (sdkObject === null || sdkObject === void 0 ? void 0 : sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata));
-    const response = {
-      id
-    };
+    await sdkObject.instrumentation.onBeforeCall(sdkObject, callMetadata);
+    const response = { id };
     try {
-      const result = await dispatcher._handleCommand(callMetadata, method, validParams);
-      const validator = (0, _validator.findValidator)(dispatcher._type, method, 'Result');
-      response.result = validator(result, '', this._validatorToWireContext());
+      const result = await dispatcher._runCommand(callMetadata, method, validParams);
+      const validator = (0, import_validator.findValidator)(dispatcher._type, method, "Result");
+      response.result = validator(result, "", this._validatorToWireContext());
       callMetadata.result = result;
     } catch (e) {
-      if ((0, _errors.isTargetClosedError)(e) && sdkObject) {
+      if ((0, import_errors.isTargetClosedError)(e)) {
         const reason = closeReason(sdkObject);
-        if (reason) (0, _utils.rewriteErrorMessage)(e, reason);
-      } else if ((0, _protocolError.isProtocolError)(e)) {
-        if (e.type === 'closed') {
-          const reason = sdkObject ? closeReason(sdkObject) : undefined;
-          e = new _errors.TargetClosedError(reason, e.browserLogMessage());
-        } else if (e.type === 'crashed') {
-          (0, _utils.rewriteErrorMessage)(e, 'Target crashed ' + e.browserLogMessage());
-        }
+        if (reason)
+          (0, import_utils.rewriteErrorMessage)(e, reason);
+      } else if ((0, import_protocolError.isProtocolError)(e)) {
+        if (e.type === "closed")
+          e = new import_errors.TargetClosedError(closeReason(sdkObject), e.browserLogMessage());
+        else if (e.type === "crashed")
+          (0, import_utils.rewriteErrorMessage)(e, "Target crashed " + e.browserLogMessage());
       }
-      response.error = (0, _errors.serializeError)(e);
-      // The command handler could have set error in the metadata, do not reset it if there was no exception.
+      response.error = (0, import_errors.serializeError)(e);
       callMetadata.error = response.error;
     } finally {
-      callMetadata.endTime = (0, _utils.monotonicTime)();
-      await (sdkObject === null || sdkObject === void 0 ? void 0 : sdkObject.instrumentation.onAfterCall(sdkObject, callMetadata));
+      callMetadata.endTime = (0, import_utils.monotonicTime)();
+      await sdkObject.instrumentation.onAfterCall(sdkObject, callMetadata);
     }
-    if (response.error) response.log = (0, _callLog.compressCallLog)(callMetadata.log);
+    if (response.error)
+      response.log = (0, import_callLog.compressCallLog)(callMetadata.log);
     this.onmessage(response);
   }
 }
-exports.DispatcherConnection = DispatcherConnection;
 function closeReason(sdkObject) {
-  var _sdkObject$attributio3, _sdkObject$attributio4, _sdkObject$attributio5;
-  return ((_sdkObject$attributio3 = sdkObject.attribution.page) === null || _sdkObject$attributio3 === void 0 ? void 0 : _sdkObject$attributio3._closeReason) || ((_sdkObject$attributio4 = sdkObject.attribution.context) === null || _sdkObject$attributio4 === void 0 ? void 0 : _sdkObject$attributio4._closeReason) || ((_sdkObject$attributio5 = sdkObject.attribution.browser) === null || _sdkObject$attributio5 === void 0 ? void 0 : _sdkObject$attributio5._closeReason);
-}
+  return sdkObject.attribution.page?.closeReason || sdkObject.attribution.context?._closeReason || sdkObject.attribution.browser?._closeReason;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Dispatcher,
+  DispatcherConnection,
+  RootDispatcher,
+  setMaxDispatchersForTest
+});