@trigger.dev/redis-worker 4.5.0-rc.4 → 4.5.0-rc.5

package/dist/index.cjs

@@ -3624,12 +3624,12 @@ var require_common = __commonJS({
           if (!debug.enabled) {
             return;
           }
-          const self = debug;
+          const self2 = debug;
           const curr = Number(/* @__PURE__ */ new Date());
           const ms = curr - (prevTime || curr);
-          self.diff = ms;
-          self.prev = prevTime;
-          self.curr = curr;
+          self2.diff = ms;
+          self2.prev = prevTime;
+          self2.curr = curr;
           prevTime = curr;
           args[0] = createDebug.coerce(args[0]);
           if (typeof args[0] !== "string") {
@@ -3644,15 +3644,15 @@ var require_common = __commonJS({
             const formatter = createDebug.formatters[format];
             if (typeof formatter === "function") {
               const val = args[index];
-              match = formatter.call(self, val);
+              match = formatter.call(self2, val);
               args.splice(index, 1);
               index--;
             }
             return match;
           });
-          createDebug.formatArgs.call(self, args);
-          const logFn = self.log || createDebug.log;
-          logFn.apply(self, args);
+          createDebug.formatArgs.call(self2, args);
+          const logFn = self2.log || createDebug.log;
+          logFn.apply(self2, args);
         }
         debug.namespace = namespace;
         debug.useColors = createDebug.useColors();
@@ -7200,7 +7200,7 @@ var require_cluster = __commonJS({
             if (err) {
               return reject(err);
             }
-            const self = this, groupedRecords = (0, util_1.groupSrvRecords)(records), sortedKeys = Object.keys(groupedRecords).sort((a, b) => parseInt(a) - parseInt(b));
+            const self2 = this, groupedRecords = (0, util_1.groupSrvRecords)(records), sortedKeys = Object.keys(groupedRecords).sort((a, b) => parseInt(a) - parseInt(b));
             function tryFirstOne(err2) {
               if (!sortedKeys.length) {
                 return reject(err2);
@@ -7209,7 +7209,7 @@ var require_cluster = __commonJS({
               if (!group.records.length) {
                 sortedKeys.shift();
               }
-              self.dnsLookup(record.name).then((host) => resolve({
+              self2.dnsLookup(record.name).then((host) => resolve({
                 host,
                 port: record.port
               }), tryFirstOne);
@@ -8416,15 +8416,15 @@ var require_event_handler = __commonJS({
     var utils_1 = require_utils2();
     var DataHandler_1 = require_DataHandler();
     var debug = (0, utils_1.Debug)("connection");
-    function connectHandler(self) {
+    function connectHandler(self2) {
       return function() {
-        self.setStatus("connect");
-        self.resetCommandQueue();
+        self2.setStatus("connect");
+        self2.resetCommandQueue();
         let flushed = false;
-        const { connectionEpoch } = self;
-        if (self.condition.auth) {
-          self.auth(self.condition.auth, function(err) {
-            if (connectionEpoch !== self.connectionEpoch) {
+        const { connectionEpoch } = self2;
+        if (self2.condition.auth) {
+          self2.auth(self2.condition.auth, function(err) {
+            if (connectionEpoch !== self2.connectionEpoch) {
               return;
             }
             if (err) {
@@ -8436,36 +8436,36 @@ var require_event_handler = __commonJS({
                 console.warn(`[ERROR] The server returned "wrong number of arguments for 'auth' command". You are probably passing both username and password to Redis version 5 or below. You should only pass the 'password' option for Redis version 5 and under.`);
               } else {
                 flushed = true;
-                self.recoverFromFatalError(err, err);
+                self2.recoverFromFatalError(err, err);
               }
             }
           });
         }
-        if (self.condition.select) {
-          self.select(self.condition.select).catch((err) => {
-            self.silentEmit("error", err);
+        if (self2.condition.select) {
+          self2.select(self2.condition.select).catch((err) => {
+            self2.silentEmit("error", err);
           });
         }
-        if (!self.options.enableReadyCheck) {
-          exports$1.readyHandler(self)();
+        if (!self2.options.enableReadyCheck) {
+          exports$1.readyHandler(self2)();
         }
-        new DataHandler_1.default(self, {
-          stringNumbers: self.options.stringNumbers
+        new DataHandler_1.default(self2, {
+          stringNumbers: self2.options.stringNumbers
         });
-        if (self.options.enableReadyCheck) {
-          self._readyCheck(function(err, info) {
-            if (connectionEpoch !== self.connectionEpoch) {
+        if (self2.options.enableReadyCheck) {
+          self2._readyCheck(function(err, info) {
+            if (connectionEpoch !== self2.connectionEpoch) {
               return;
             }
             if (err) {
               if (!flushed) {
-                self.recoverFromFatalError(new Error("Ready check failed: " + err.message), err);
+                self2.recoverFromFatalError(new Error("Ready check failed: " + err.message), err);
               }
             } else {
-              if (self.connector.check(info)) {
-                exports$1.readyHandler(self)();
+              if (self2.connector.check(info)) {
+                exports$1.readyHandler(self2)();
               } else {
-                self.disconnect(true);
+                self2.disconnect(true);
               }
             }
           });
@@ -8518,152 +8518,152 @@ var require_event_handler = __commonJS({
         }
       }
     }
-    function closeHandler(self) {
+    function closeHandler(self2) {
       return function() {
-        const prevStatus = self.status;
-        self.setStatus("close");
-        if (self.commandQueue.length) {
-          abortIncompletePipelines(self.commandQueue);
+        const prevStatus = self2.status;
+        self2.setStatus("close");
+        if (self2.commandQueue.length) {
+          abortIncompletePipelines(self2.commandQueue);
         }
-        if (self.offlineQueue.length) {
-          abortTransactionFragments(self.offlineQueue);
+        if (self2.offlineQueue.length) {
+          abortTransactionFragments(self2.offlineQueue);
         }
         if (prevStatus === "ready") {
-          if (!self.prevCondition) {
-            self.prevCondition = self.condition;
+          if (!self2.prevCondition) {
+            self2.prevCondition = self2.condition;
           }
-          if (self.commandQueue.length) {
-            self.prevCommandQueue = self.commandQueue;
+          if (self2.commandQueue.length) {
+            self2.prevCommandQueue = self2.commandQueue;
           }
         }
-        if (self.manuallyClosing) {
-          self.manuallyClosing = false;
+        if (self2.manuallyClosing) {
+          self2.manuallyClosing = false;
           debug("skip reconnecting since the connection is manually closed.");
           return close();
         }
-        if (typeof self.options.retryStrategy !== "function") {
+        if (typeof self2.options.retryStrategy !== "function") {
           debug("skip reconnecting because `retryStrategy` is not a function");
           return close();
         }
-        const retryDelay = self.options.retryStrategy(++self.retryAttempts);
+        const retryDelay = self2.options.retryStrategy(++self2.retryAttempts);
         if (typeof retryDelay !== "number") {
           debug("skip reconnecting because `retryStrategy` doesn't return a number");
           return close();
         }
         debug("reconnect in %sms", retryDelay);
-        self.setStatus("reconnecting", retryDelay);
-        self.reconnectTimeout = setTimeout(function() {
-          self.reconnectTimeout = null;
-          self.connect().catch(utils_1.noop);
+        self2.setStatus("reconnecting", retryDelay);
+        self2.reconnectTimeout = setTimeout(function() {
+          self2.reconnectTimeout = null;
+          self2.connect().catch(utils_1.noop);
         }, retryDelay);
-        const { maxRetriesPerRequest } = self.options;
+        const { maxRetriesPerRequest } = self2.options;
         if (typeof maxRetriesPerRequest === "number") {
           if (maxRetriesPerRequest < 0) {
             debug("maxRetriesPerRequest is negative, ignoring...");
           } else {
-            const remainder = self.retryAttempts % (maxRetriesPerRequest + 1);
+            const remainder = self2.retryAttempts % (maxRetriesPerRequest + 1);
             if (remainder === 0) {
               debug("reach maxRetriesPerRequest limitation, flushing command queue...");
-              self.flushQueue(new errors_1.MaxRetriesPerRequestError(maxRetriesPerRequest));
+              self2.flushQueue(new errors_1.MaxRetriesPerRequestError(maxRetriesPerRequest));
             }
           }
         }
       };
       function close() {
-        self.setStatus("end");
-        self.flushQueue(new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG));
+        self2.setStatus("end");
+        self2.flushQueue(new Error(utils_1.CONNECTION_CLOSED_ERROR_MSG));
       }
     }
     exports$1.closeHandler = closeHandler;
-    function errorHandler(self) {
+    function errorHandler(self2) {
       return function(error) {
         debug("error: %s", error);
-        self.silentEmit("error", error);
+        self2.silentEmit("error", error);
       };
     }
     exports$1.errorHandler = errorHandler;
-    function readyHandler(self) {
+    function readyHandler(self2) {
       return function() {
-        self.setStatus("ready");
-        self.retryAttempts = 0;
-        if (self.options.monitor) {
-          self.call("monitor").then(() => self.setStatus("monitoring"), (error) => self.emit("error", error));
-          const { sendCommand } = self;
-          self.sendCommand = function(command) {
+        self2.setStatus("ready");
+        self2.retryAttempts = 0;
+        if (self2.options.monitor) {
+          self2.call("monitor").then(() => self2.setStatus("monitoring"), (error) => self2.emit("error", error));
+          const { sendCommand } = self2;
+          self2.sendCommand = function(command) {
             if (Command_1.default.checkFlag("VALID_IN_MONITOR_MODE", command.name)) {
-              return sendCommand.call(self, command);
+              return sendCommand.call(self2, command);
             }
             command.reject(new Error("Connection is in monitoring mode, can't process commands."));
             return command.promise;
           };
-          self.once("close", function() {
-            delete self.sendCommand;
+          self2.once("close", function() {
+            delete self2.sendCommand;
           });
           return;
         }
-        const finalSelect = self.prevCondition ? self.prevCondition.select : self.condition.select;
-        if (self.options.connectionName) {
-          debug("set the connection name [%s]", self.options.connectionName);
-          self.client("setname", self.options.connectionName).catch(utils_1.noop);
+        const finalSelect = self2.prevCondition ? self2.prevCondition.select : self2.condition.select;
+        if (self2.options.connectionName) {
+          debug("set the connection name [%s]", self2.options.connectionName);
+          self2.client("setname", self2.options.connectionName).catch(utils_1.noop);
         }
-        if (self.options.readOnly) {
+        if (self2.options.readOnly) {
           debug("set the connection to readonly mode");
-          self.readonly().catch(utils_1.noop);
+          self2.readonly().catch(utils_1.noop);
         }
-        if (self.prevCondition) {
-          const condition = self.prevCondition;
-          self.prevCondition = null;
-          if (condition.subscriber && self.options.autoResubscribe) {
-            if (self.condition.select !== finalSelect) {
+        if (self2.prevCondition) {
+          const condition = self2.prevCondition;
+          self2.prevCondition = null;
+          if (condition.subscriber && self2.options.autoResubscribe) {
+            if (self2.condition.select !== finalSelect) {
               debug("connect to db [%d]", finalSelect);
-              self.select(finalSelect);
+              self2.select(finalSelect);
             }
             const subscribeChannels = condition.subscriber.channels("subscribe");
             if (subscribeChannels.length) {
               debug("subscribe %d channels", subscribeChannels.length);
-              self.subscribe(subscribeChannels);
+              self2.subscribe(subscribeChannels);
             }
             const psubscribeChannels = condition.subscriber.channels("psubscribe");
             if (psubscribeChannels.length) {
               debug("psubscribe %d channels", psubscribeChannels.length);
-              self.psubscribe(psubscribeChannels);
+              self2.psubscribe(psubscribeChannels);
             }
             const ssubscribeChannels = condition.subscriber.channels("ssubscribe");
             if (ssubscribeChannels.length) {
               debug("ssubscribe %d channels", ssubscribeChannels.length);
-              self.ssubscribe(ssubscribeChannels);
+              self2.ssubscribe(ssubscribeChannels);
             }
           }
         }
-        if (self.prevCommandQueue) {
-          if (self.options.autoResendUnfulfilledCommands) {
-            debug("resend %d unfulfilled commands", self.prevCommandQueue.length);
-            while (self.prevCommandQueue.length > 0) {
-              const item = self.prevCommandQueue.shift();
-              if (item.select !== self.condition.select && item.command.name !== "select") {
-                self.select(item.select);
+        if (self2.prevCommandQueue) {
+          if (self2.options.autoResendUnfulfilledCommands) {
+            debug("resend %d unfulfilled commands", self2.prevCommandQueue.length);
+            while (self2.prevCommandQueue.length > 0) {
+              const item = self2.prevCommandQueue.shift();
+              if (item.select !== self2.condition.select && item.command.name !== "select") {
+                self2.select(item.select);
               }
-              self.sendCommand(item.command, item.stream);
+              self2.sendCommand(item.command, item.stream);
             }
           } else {
-            self.prevCommandQueue = null;
+            self2.prevCommandQueue = null;
           }
         }
-        if (self.offlineQueue.length) {
-          debug("send %d commands in offline queue", self.offlineQueue.length);
-          const offlineQueue = self.offlineQueue;
-          self.resetOfflineQueue();
+        if (self2.offlineQueue.length) {
+          debug("send %d commands in offline queue", self2.offlineQueue.length);
+          const offlineQueue = self2.offlineQueue;
+          self2.resetOfflineQueue();
           while (offlineQueue.length > 0) {
             const item = offlineQueue.shift();
-            if (item.select !== self.condition.select && item.command.name !== "select") {
-              self.select(item.select);
+            if (item.select !== self2.condition.select && item.command.name !== "select") {
+              self2.select(item.select);
             }
-            self.sendCommand(item.command, item.stream);
+            self2.sendCommand(item.command, item.stream);
           }
         }
-        if (self.condition.select !== finalSelect) {
+        if (self2.condition.select !== finalSelect) {
           debug("connect to db [%d]", finalSelect);
-          self.select(finalSelect);
+          self2.select(finalSelect);
         }
       };
     }
@@ -9959,24 +9959,19 @@ var SimpleQueue = class {
   }
 };
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/platform/node/globalThis.js
-var _globalThis = typeof globalThis === "object" ? globalThis : global;
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/version.js
+var VERSION = "1.9.1";
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/version.js
-var VERSION = "1.9.0";
-
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/semver.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/semver.js
 var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
 function _makeCompatibilityCheck(ownVersion) {
-  var acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
-  var rejectedVersions = /* @__PURE__ */ new Set();
-  var myVersionMatch = ownVersion.match(re);
+  const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+  const rejectedVersions = /* @__PURE__ */ new Set();
+  const myVersionMatch = ownVersion.match(re);
   if (!myVersionMatch) {
-    return function() {
-      return false;
-    };
+    return () => false;
   }
-  var ownVersionParsed = {
+  const ownVersionParsed = {
     major: +myVersionMatch[1],
     minor: +myVersionMatch[2],
     patch: +myVersionMatch[3],
@@ -10002,11 +9997,11 @@ function _makeCompatibilityCheck(ownVersion) {
     if (rejectedVersions.has(globalVersion)) {
       return false;
     }
-    var globalVersionMatch = globalVersion.match(re);
+    const globalVersionMatch = globalVersion.match(re);
     if (!globalVersionMatch) {
       return _reject(globalVersion);
     }
-    var globalVersionParsed = {
+    const globalVersionParsed = {
       major: +globalVersionMatch[1],
       minor: +globalVersionMatch[2],
       patch: +globalVersionMatch[3],
@@ -10032,129 +10027,75 @@ function _makeCompatibilityCheck(ownVersion) {
 }
 var isCompatible = _makeCompatibilityCheck(VERSION);
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
 var major = VERSION.split(".")[0];
-var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for("opentelemetry.js.api." + major);
-var _global = _globalThis;
-function registerGlobal(type, instance, diag, allowOverride) {
+var GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag, allowOverride = false) {
   var _a;
-  if (allowOverride === void 0) {
-    allowOverride = false;
-  }
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
     version: VERSION
   };
   if (!allowOverride && api[type]) {
-    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
     diag.error(err.stack || err.message);
     return false;
   }
   if (api.version !== VERSION) {
-    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION);
+    const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
     diag.error(err.stack || err.message);
     return false;
   }
   api[type] = instance;
-  diag.debug("@opentelemetry/api: Registered a global for " + type + " v" + VERSION + ".");
+  diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
   return true;
 }
 function getGlobal(type) {
   var _a, _b;
-  var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+  const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
   if (!globalVersion || !isCompatible(globalVersion)) {
     return;
   }
   return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
 }
 function unregisterGlobal(type, diag) {
-  diag.debug("@opentelemetry/api: Unregistering a global for " + type + " v" + VERSION + ".");
-  var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+  diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+  const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
   if (api) {
     delete api[type];
   }
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
-var __read = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+var DiagComponentLogger = class {
+  constructor(props) {
+    this._namespace = props.namespace || "DiagComponentLogger";
   }
-  return ar;
-};
-var __spreadArray = function(to, from, pack) {
-  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
+  debug(...args) {
+    return logProxy("debug", this._namespace, args);
+  }
+  error(...args) {
+    return logProxy("error", this._namespace, args);
+  }
+  info(...args) {
+    return logProxy("info", this._namespace, args);
+  }
+  warn(...args) {
+    return logProxy("warn", this._namespace, args);
+  }
+  verbose(...args) {
+    return logProxy("verbose", this._namespace, args);
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
 };
-var DiagComponentLogger = (
-  /** @class */
-  function() {
-    function DiagComponentLogger2(props) {
-      this._namespace = props.namespace || "DiagComponentLogger";
-    }
-    DiagComponentLogger2.prototype.debug = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("debug", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.error = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("error", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.info = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("info", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.warn = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("warn", this._namespace, args);
-    };
-    DiagComponentLogger2.prototype.verbose = function() {
-      var args = [];
-      for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-      }
-      return logProxy("verbose", this._namespace, args);
-    };
-    return DiagComponentLogger2;
-  }()
-);
 function logProxy(funcName, namespace, args) {
-  var logger2 = getGlobal("diag");
+  const logger2 = getGlobal("diag");
   if (!logger2) {
     return;
   }
-  args.unshift(namespace);
-  return logger2[funcName].apply(logger2, __spreadArray([], __read(args), false));
+  return logger2[funcName](namespace, ...args);
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/types.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/types.js
 var DiagLogLevel;
 (function(DiagLogLevel2) {
   DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
@@ -10166,7 +10107,7 @@ var DiagLogLevel;
   DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
 })(DiagLogLevel || (DiagLogLevel = {}));
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
 function createLogLevelDiagLogger(maxLevel, logger2) {
   if (maxLevel < DiagLogLevel.NONE) {
     maxLevel = DiagLogLevel.NONE;
@@ -10175,7 +10116,7 @@ function createLogLevelDiagLogger(maxLevel, logger2) {
   }
   logger2 = logger2 || {};
   function _filterFunc(funcName, theLevel) {
-    var theFunc = logger2[funcName];
+    const theFunc = logger2[funcName];
     if (typeof theFunc === "function" && maxLevel >= theLevel) {
       return theFunc.bind(logger2);
     }
@@ -10191,278 +10132,181 @@ function createLogLevelDiagLogger(maxLevel, logger2) {
   };
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/diag.js
-var __read2 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/diag.js
+var API_NAME = "diag";
+var DiagAPI = class _DiagAPI {
+  /** Get the singleton instance of the DiagAPI API */
+  static instance() {
+    if (!this._instance) {
+      this._instance = new _DiagAPI();
     }
+    return this._instance;
   }
-  return ar;
-};
-var __spreadArray2 = function(to, from, pack) {
-  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
+  /**
+   * Private internal constructor
+   * @private
+   */
+  constructor() {
+    function _logProxy(funcName) {
+      return function(...args) {
+        const logger2 = getGlobal("diag");
+        if (!logger2)
+          return;
+        return logger2[funcName](...args);
+      };
     }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var API_NAME = "diag";
-var DiagAPI = (
-  /** @class */
-  function() {
-    function DiagAPI2() {
-      function _logProxy(funcName) {
-        return function() {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          var logger2 = getGlobal("diag");
-          if (!logger2)
-            return;
-          return logger2[funcName].apply(logger2, __spreadArray2([], __read2(args), false));
+    const self2 = this;
+    const setLogger = (logger2, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+      var _a, _b, _c;
+      if (logger2 === self2) {
+        const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+        self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+        return false;
+      }
+      if (typeof optionsOrLogLevel === "number") {
+        optionsOrLogLevel = {
+          logLevel: optionsOrLogLevel
         };
       }
-      var self = this;
-      var setLogger = function(logger2, optionsOrLogLevel) {
-        var _a, _b, _c;
-        if (optionsOrLogLevel === void 0) {
-          optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
-        }
-        if (logger2 === self) {
-          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-          self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
-          return false;
-        }
-        if (typeof optionsOrLogLevel === "number") {
-          optionsOrLogLevel = {
-            logLevel: optionsOrLogLevel
-          };
-        }
-        var oldLogger = getGlobal("diag");
-        var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger2);
-        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
-          var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
-          oldLogger.warn("Current logger will be overwritten from " + stack);
-          newLogger.warn("Current logger will overwrite one already registered from " + stack);
-        }
-        return registerGlobal("diag", newLogger, self, true);
-      };
-      self.setLogger = setLogger;
-      self.disable = function() {
-        unregisterGlobal(API_NAME, self);
-      };
-      self.createComponentLogger = function(options) {
-        return new DiagComponentLogger(options);
-      };
-      self.verbose = _logProxy("verbose");
-      self.debug = _logProxy("debug");
-      self.info = _logProxy("info");
-      self.warn = _logProxy("warn");
-      self.error = _logProxy("error");
-    }
-    DiagAPI2.instance = function() {
-      if (!this._instance) {
-        this._instance = new DiagAPI2();
+      const oldLogger = getGlobal("diag");
+      const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger2);
+      if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+        const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+        oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+        newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
       }
-      return this._instance;
+      return registerGlobal("diag", newLogger, self2, true);
+    };
+    self2.setLogger = setLogger;
+    self2.disable = () => {
+      unregisterGlobal(API_NAME, self2);
     };
-    return DiagAPI2;
-  }()
-);
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
+    };
+    self2.verbose = _logProxy("verbose");
+    self2.debug = _logProxy("debug");
+    self2.info = _logProxy("info");
+    self2.warn = _logProxy("warn");
+    self2.error = _logProxy("error");
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/context.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/context.js
 function createContextKey(description) {
   return Symbol.for(description);
 }
-var BaseContext = (
-  /** @class */
-  /* @__PURE__ */ function() {
-    function BaseContext2(parentContext) {
-      var self = this;
-      self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
-      self.getValue = function(key) {
-        return self._currentContext.get(key);
-      };
-      self.setValue = function(key, value) {
-        var context2 = new BaseContext2(self._currentContext);
-        context2._currentContext.set(key, value);
-        return context2;
-      };
-      self.deleteValue = function(key) {
-        var context2 = new BaseContext2(self._currentContext);
-        context2._currentContext.delete(key);
-        return context2;
-      };
-    }
-    return BaseContext2;
-  }()
-);
-var ROOT_CONTEXT = new BaseContext();
-
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
-var __extends = /* @__PURE__ */ function() {
-  var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-      d2.__proto__ = b2;
-    } || function(d2, b2) {
-      for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
-    };
-    return extendStatics(d, b);
-  };
-  return function(d, b) {
-    if (typeof b !== "function" && b !== null)
-      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() {
-      this.constructor = d;
-    }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-  };
-}();
-var NoopMeter = (
-  /** @class */
-  function() {
-    function NoopMeter2() {
-    }
-    NoopMeter2.prototype.createGauge = function(_name, _options) {
-      return NOOP_GAUGE_METRIC;
-    };
-    NoopMeter2.prototype.createHistogram = function(_name, _options) {
-      return NOOP_HISTOGRAM_METRIC;
-    };
-    NoopMeter2.prototype.createCounter = function(_name, _options) {
-      return NOOP_COUNTER_METRIC;
-    };
-    NoopMeter2.prototype.createUpDownCounter = function(_name, _options) {
-      return NOOP_UP_DOWN_COUNTER_METRIC;
-    };
-    NoopMeter2.prototype.createObservableGauge = function(_name, _options) {
-      return NOOP_OBSERVABLE_GAUGE_METRIC;
-    };
-    NoopMeter2.prototype.createObservableCounter = function(_name, _options) {
-      return NOOP_OBSERVABLE_COUNTER_METRIC;
-    };
-    NoopMeter2.prototype.createObservableUpDownCounter = function(_name, _options) {
-      return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
-    };
-    NoopMeter2.prototype.addBatchObservableCallback = function(_callback, _observables) {
-    };
-    NoopMeter2.prototype.removeBatchObservableCallback = function(_callback) {
-    };
-    return NoopMeter2;
-  }()
-);
-var NoopMetric = (
-  /** @class */
-  /* @__PURE__ */ function() {
-    function NoopMetric2() {
-    }
-    return NoopMetric2;
-  }()
-);
-var NoopCounterMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopCounterMetric2, _super);
-    function NoopCounterMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopCounterMetric2.prototype.add = function(_value, _attributes) {
-    };
-    return NoopCounterMetric2;
-  }(NoopMetric)
-);
-var NoopUpDownCounterMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopUpDownCounterMetric2, _super);
-    function NoopUpDownCounterMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopUpDownCounterMetric2.prototype.add = function(_value, _attributes) {
-    };
-    return NoopUpDownCounterMetric2;
-  }(NoopMetric)
-);
-var NoopGaugeMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopGaugeMetric2, _super);
-    function NoopGaugeMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopGaugeMetric2.prototype.record = function(_value, _attributes) {
-    };
-    return NoopGaugeMetric2;
-  }(NoopMetric)
-);
-var NoopHistogramMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopHistogramMetric2, _super);
-    function NoopHistogramMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    NoopHistogramMetric2.prototype.record = function(_value, _attributes) {
-    };
-    return NoopHistogramMetric2;
-  }(NoopMetric)
-);
-var NoopObservableMetric = (
-  /** @class */
-  function() {
-    function NoopObservableMetric2() {
-    }
-    NoopObservableMetric2.prototype.addCallback = function(_callback) {
+var BaseContext = class _BaseContext {
+  /**
+   * Construct a new context which inherits values from an optional parent context.
+   *
+   * @param parentContext a context from which to inherit values
+   */
+  constructor(parentContext) {
+    const self2 = this;
+    self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+    self2.getValue = (key) => self2._currentContext.get(key);
+    self2.setValue = (key, value) => {
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.set(key, value);
+      return context2;
     };
-    NoopObservableMetric2.prototype.removeCallback = function(_callback) {
+    self2.deleteValue = (key) => {
+      const context2 = new _BaseContext(self2._currentContext);
+      context2._currentContext.delete(key);
+      return context2;
     };
-    return NoopObservableMetric2;
-  }()
-);
-var NoopObservableCounterMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopObservableCounterMetric2, _super);
-    function NoopObservableCounterMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableCounterMetric2;
-  }(NoopObservableMetric)
-);
-var NoopObservableGaugeMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopObservableGaugeMetric2, _super);
-    function NoopObservableGaugeMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableGaugeMetric2;
-  }(NoopObservableMetric)
-);
-var NoopObservableUpDownCounterMetric = (
-  /** @class */
-  function(_super) {
-    __extends(NoopObservableUpDownCounterMetric2, _super);
-    function NoopObservableUpDownCounterMetric2() {
-      return _super !== null && _super.apply(this, arguments) || this;
-    }
-    return NoopObservableUpDownCounterMetric2;
-  }(NoopObservableMetric)
-);
+  }
+};
+var ROOT_CONTEXT = new BaseContext();
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js
+var NoopMeter = class {
+  constructor() {
+  }
+  /**
+   * @see {@link Meter.createGauge}
+   */
+  createGauge(_name, _options) {
+    return NOOP_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createHistogram}
+   */
+  createHistogram(_name, _options) {
+    return NOOP_HISTOGRAM_METRIC;
+  }
+  /**
+   * @see {@link Meter.createCounter}
+   */
+  createCounter(_name, _options) {
+    return NOOP_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createUpDownCounter}
+   */
+  createUpDownCounter(_name, _options) {
+    return NOOP_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableGauge}
+   */
+  createObservableGauge(_name, _options) {
+    return NOOP_OBSERVABLE_GAUGE_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableCounter}
+   */
+  createObservableCounter(_name, _options) {
+    return NOOP_OBSERVABLE_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.createObservableUpDownCounter}
+   */
+  createObservableUpDownCounter(_name, _options) {
+    return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
+  }
+  /**
+   * @see {@link Meter.addBatchObservableCallback}
+   */
+  addBatchObservableCallback(_callback, _observables) {
+  }
+  /**
+   * @see {@link Meter.removeBatchObservableCallback}
+   */
+  removeBatchObservableCallback(_callback) {
+  }
+};
+var NoopMetric = class {
+};
+var NoopCounterMetric = class extends NoopMetric {
+  add(_value, _attributes) {
+  }
+};
+var NoopUpDownCounterMetric = class extends NoopMetric {
+  add(_value, _attributes) {
+  }
+};
+var NoopGaugeMetric = class extends NoopMetric {
+  record(_value, _attributes) {
+  }
+};
+var NoopHistogramMetric = class extends NoopMetric {
+  record(_value, _attributes) {
+  }
+};
+var NoopObservableMetric = class {
+  addCallback(_callback) {
+  }
+  removeCallback(_callback) {
+  }
+};
+var NoopObservableCounterMetric = class extends NoopObservableMetric {
+};
+var NoopObservableGaugeMetric = class extends NoopObservableMetric {
+};
+var NoopObservableUpDownCounterMetric = class extends NoopObservableMetric {
+};
 var NOOP_METER = new NoopMeter();
 var NOOP_COUNTER_METRIC = new NoopCounterMetric();
 var NOOP_GAUGE_METRIC = new NoopGaugeMetric();
@@ -10472,144 +10316,98 @@ var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
 var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
 var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/Metric.js
 var ValueType;
 (function(ValueType2) {
   ValueType2[ValueType2["INT"] = 0] = "INT";
   ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
 })(ValueType || (ValueType = {}));
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
-var __read3 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager = class {
+  active() {
+    return ROOT_CONTEXT;
   }
-  return ar;
-};
-var __spreadArray3 = function(to, from, pack) {
-  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
+  with(_context, fn, thisArg, ...args) {
+    return fn.call(thisArg, ...args);
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
-};
-var NoopContextManager = (
-  /** @class */
-  function() {
-    function NoopContextManager2() {
-    }
-    NoopContextManager2.prototype.active = function() {
-      return ROOT_CONTEXT;
-    };
-    NoopContextManager2.prototype.with = function(_context, fn, thisArg) {
-      var args = [];
-      for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-      }
-      return fn.call.apply(fn, __spreadArray3([thisArg], __read3(args), false));
-    };
-    NoopContextManager2.prototype.bind = function(_context, target) {
-      return target;
-    };
-    NoopContextManager2.prototype.enable = function() {
-      return this;
-    };
-    NoopContextManager2.prototype.disable = function() {
-      return this;
-    };
-    return NoopContextManager2;
-  }()
-);
-
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/context.js
-var __read4 = function(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  } catch (error) {
-    e = { error };
-  } finally {
-    try {
-      if (r && !r.done && (m = i["return"])) m.call(i);
-    } finally {
-      if (e) throw e.error;
-    }
+  bind(_context, target) {
+    return target;
   }
-  return ar;
-};
-var __spreadArray4 = function(to, from, pack) {
-  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
-    }
+  enable() {
+    return this;
+  }
+  disable() {
+    return this;
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
 };
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/context.js
 var API_NAME2 = "context";
 var NOOP_CONTEXT_MANAGER = new NoopContextManager();
-var ContextAPI = (
-  /** @class */
-  function() {
-    function ContextAPI2() {
+var ContextAPI = class _ContextAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Context API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _ContextAPI();
     }
-    ContextAPI2.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new ContextAPI2();
-      }
-      return this._instance;
-    };
-    ContextAPI2.prototype.setGlobalContextManager = function(contextManager) {
-      return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
-    };
-    ContextAPI2.prototype.active = function() {
-      return this._getContextManager().active();
-    };
-    ContextAPI2.prototype.with = function(context2, fn, thisArg) {
-      var _a;
-      var args = [];
-      for (var _i = 3; _i < arguments.length; _i++) {
-        args[_i - 3] = arguments[_i];
-      }
-      return (_a = this._getContextManager()).with.apply(_a, __spreadArray4([context2, fn, thisArg], __read4(args), false));
-    };
-    ContextAPI2.prototype.bind = function(context2, target) {
-      return this._getContextManager().bind(context2, target);
-    };
-    ContextAPI2.prototype._getContextManager = function() {
-      return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
-    };
-    ContextAPI2.prototype.disable = function() {
-      this._getContextManager().disable();
-      unregisterGlobal(API_NAME2, DiagAPI.instance());
-    };
-    return ContextAPI2;
-  }()
-);
+    return this._instance;
+  }
+  /**
+   * Set the current context manager.
+   *
+   * @returns true if the context manager was successfully registered, else false
+   */
+  setGlobalContextManager(contextManager) {
+    return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+  }
+  /**
+   * Get the currently active context
+   */
+  active() {
+    return this._getContextManager().active();
+  }
+  /**
+   * Execute a function with an active context
+   *
+   * @param context context to be active during function execution
+   * @param fn function to execute in a context
+   * @param thisArg optional receiver to be used for calling fn
+   * @param args optional arguments forwarded to fn
+   */
+  with(context2, fn, thisArg, ...args) {
+    return this._getContextManager().with(context2, fn, thisArg, ...args);
+  }
+  /**
+   * Bind a context to a target function or event emitter
+   *
+   * @param context context to bind to the event emitter or function. Defaults to the currently active context
+   * @param target function or event emitter to bind
+   */
+  bind(context2, target) {
+    return this._getContextManager().bind(context2, target);
+  }
+  _getContextManager() {
+    return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+  }
+  /** Disable and remove the global context manager */
+  disable() {
+    this._getContextManager().disable();
+    unregisterGlobal(API_NAME2, DiagAPI.instance());
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
 var TraceFlags;
 (function(TraceFlags2) {
   TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
   TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
 })(TraceFlags || (TraceFlags = {}));
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
 var INVALID_SPANID = "0000000000000000";
 var INVALID_TRACEID = "00000000000000000000000000000000";
 var INVALID_SPAN_CONTEXT = {
@@ -10618,52 +10416,54 @@ var INVALID_SPAN_CONTEXT = {
   traceFlags: TraceFlags.NONE
 };
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
-var NonRecordingSpan = (
-  /** @class */
-  function() {
-    function NonRecordingSpan2(_spanContext) {
-      if (_spanContext === void 0) {
-        _spanContext = INVALID_SPAN_CONTEXT;
-      }
-      this._spanContext = _spanContext;
-    }
-    NonRecordingSpan2.prototype.spanContext = function() {
-      return this._spanContext;
-    };
-    NonRecordingSpan2.prototype.setAttribute = function(_key, _value) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.setAttributes = function(_attributes) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addEvent = function(_name, _attributes) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addLink = function(_link) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.addLinks = function(_links) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.setStatus = function(_status) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.updateName = function(_name) {
-      return this;
-    };
-    NonRecordingSpan2.prototype.end = function(_endTime) {
-    };
-    NonRecordingSpan2.prototype.isRecording = function() {
-      return false;
-    };
-    NonRecordingSpan2.prototype.recordException = function(_exception, _time) {
-    };
-    return NonRecordingSpan2;
-  }()
-);
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+var NonRecordingSpan = class {
+  constructor(spanContext = INVALID_SPAN_CONTEXT) {
+    this._spanContext = spanContext;
+  }
+  // Returns a SpanContext.
+  spanContext() {
+    return this._spanContext;
+  }
+  // By default does nothing
+  setAttribute(_key, _value) {
+    return this;
+  }
+  // By default does nothing
+  setAttributes(_attributes) {
+    return this;
+  }
+  // By default does nothing
+  addEvent(_name, _attributes) {
+    return this;
+  }
+  addLink(_link) {
+    return this;
+  }
+  addLinks(_links) {
+    return this;
+  }
+  // By default does nothing
+  setStatus(_status) {
+    return this;
+  }
+  // By default does nothing
+  updateName(_name) {
+    return this;
+  }
+  // By default does nothing
+  end(_endTime) {
+  }
+  // isRecording always returns false for NonRecordingSpan.
+  isRecording() {
+    return false;
+  }
+  // By default does nothing
+  recordException(_exception, _time) {
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
 var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
 function getSpan(context2) {
   return context2.getValue(SPAN_KEY) || void 0;
@@ -10685,14 +10485,126 @@ function getSpanContext(context2) {
   return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
-var VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;
-var VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+var isHex = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  1,
+  1
+]);
+function isValidHex(id, length) {
+  if (typeof id !== "string" || id.length !== length)
+    return false;
+  let r = 0;
+  for (let i = 0; i < id.length; i += 4) {
+    r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+  }
+  return r === length;
+}
 function isValidTraceId(traceId) {
-  return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;
+  return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
 }
 function isValidSpanId(spanId) {
-  return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;
+  return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
 }
 function isSpanContextValid(spanContext) {
   return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
@@ -10701,129 +10613,115 @@ function wrapSpanContext(spanContext) {
   return new NonRecordingSpan(spanContext);
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
 var contextApi = ContextAPI.getInstance();
-var NoopTracer = (
-  /** @class */
-  function() {
-    function NoopTracer2() {
-    }
-    NoopTracer2.prototype.startSpan = function(name, options, context2) {
-      if (context2 === void 0) {
-        context2 = contextApi.active();
-      }
-      var root = Boolean(options === null || options === void 0 ? void 0 : options.root);
-      if (root) {
-        return new NonRecordingSpan();
-      }
-      var parentFromContext = context2 && getSpanContext(context2);
-      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
-        return new NonRecordingSpan(parentFromContext);
-      } else {
-        return new NonRecordingSpan();
-      }
-    };
-    NoopTracer2.prototype.startActiveSpan = function(name, arg2, arg3, arg4) {
-      var opts;
-      var ctx;
-      var fn;
-      if (arguments.length < 2) {
-        return;
-      } else if (arguments.length === 2) {
-        fn = arg2;
-      } else if (arguments.length === 3) {
-        opts = arg2;
-        fn = arg3;
-      } else {
-        opts = arg2;
-        ctx = arg3;
-        fn = arg4;
-      }
-      var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
-      var span = this.startSpan(name, opts, parentContext);
-      var contextWithSpanSet = setSpan(parentContext, span);
-      return contextApi.with(contextWithSpanSet, fn, void 0, span);
-    };
-    return NoopTracer2;
-  }()
-);
+var NoopTracer = class {
+  // startSpan starts a noop span.
+  startSpan(name, options, context2 = contextApi.active()) {
+    const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+    if (root) {
+      return new NonRecordingSpan();
+    }
+    const parentFromContext = context2 && getSpanContext(context2);
+    if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+      return new NonRecordingSpan(parentFromContext);
+    } else {
+      return new NonRecordingSpan();
+    }
+  }
+  startActiveSpan(name, arg2, arg3, arg4) {
+    let opts;
+    let ctx;
+    let fn;
+    if (arguments.length < 2) {
+      return;
+    } else if (arguments.length === 2) {
+      fn = arg2;
+    } else if (arguments.length === 3) {
+      opts = arg2;
+      fn = arg3;
+    } else {
+      opts = arg2;
+      ctx = arg3;
+      fn = arg4;
+    }
+    const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+    const span = this.startSpan(name, opts, parentContext);
+    const contextWithSpanSet = setSpan(parentContext, span);
+    return contextApi.with(contextWithSpanSet, fn, void 0, span);
+  }
+};
 function isSpanContext(spanContext) {
-  return typeof spanContext === "object" && typeof spanContext["spanId"] === "string" && typeof spanContext["traceId"] === "string" && typeof spanContext["traceFlags"] === "number";
+  return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
 }
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
 var NOOP_TRACER = new NoopTracer();
-var ProxyTracer = (
-  /** @class */
-  function() {
-    function ProxyTracer2(_provider, name, version, options) {
-      this._provider = _provider;
-      this.name = name;
-      this.version = version;
-      this.options = options;
-    }
-    ProxyTracer2.prototype.startSpan = function(name, options, context2) {
-      return this._getTracer().startSpan(name, options, context2);
-    };
-    ProxyTracer2.prototype.startActiveSpan = function(_name, _options, _context, _fn) {
-      var tracer = this._getTracer();
-      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
-    };
-    ProxyTracer2.prototype._getTracer = function() {
-      if (this._delegate) {
-        return this._delegate;
-      }
-      var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
-      if (!tracer) {
-        return NOOP_TRACER;
-      }
-      this._delegate = tracer;
+var ProxyTracer = class {
+  constructor(provider, name, version, options) {
+    this._provider = provider;
+    this.name = name;
+    this.version = version;
+    this.options = options;
+  }
+  startSpan(name, options, context2) {
+    return this._getTracer().startSpan(name, options, context2);
+  }
+  startActiveSpan(_name, _options, _context, _fn) {
+    const tracer = this._getTracer();
+    return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+  }
+  /**
+   * Try to get a tracer from the proxy tracer provider.
+   * If the proxy tracer provider has no delegate, return a noop tracer.
+   */
+  _getTracer() {
+    if (this._delegate) {
       return this._delegate;
-    };
-    return ProxyTracer2;
-  }()
-);
-
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
-var NoopTracerProvider = (
-  /** @class */
-  function() {
-    function NoopTracerProvider2() {
-    }
-    NoopTracerProvider2.prototype.getTracer = function(_name, _version, _options) {
-      return new NoopTracer();
-    };
-    return NoopTracerProvider2;
-  }()
-);
+    }
+    const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+    if (!tracer) {
+      return NOOP_TRACER;
+    }
+    this._delegate = tracer;
+    return this._delegate;
+  }
+};
+
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+var NoopTracerProvider = class {
+  getTracer(_name, _version, _options) {
+    return new NoopTracer();
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
 var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
-var ProxyTracerProvider = (
-  /** @class */
-  function() {
-    function ProxyTracerProvider2() {
-    }
-    ProxyTracerProvider2.prototype.getTracer = function(name, version, options) {
-      var _a;
-      return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
-    };
-    ProxyTracerProvider2.prototype.getDelegate = function() {
-      var _a;
-      return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
-    };
-    ProxyTracerProvider2.prototype.setDelegate = function(delegate) {
-      this._delegate = delegate;
-    };
-    ProxyTracerProvider2.prototype.getDelegateTracer = function(name, version, options) {
-      var _a;
-      return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
-    };
-    return ProxyTracerProvider2;
-  }()
-);
+var ProxyTracerProvider = class {
+  /**
+   * Get a {@link ProxyTracer}
+   */
+  getTracer(name, version, options) {
+    var _a;
+    return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+  }
+  getDelegate() {
+    var _a;
+    return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+  }
+  /**
+   * Set the delegate tracer provider
+   */
+  setDelegate(delegate) {
+    this._delegate = delegate;
+  }
+  getDelegateTracer(name, version, options) {
+    var _a;
+    return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
 var SpanKind;
 (function(SpanKind2) {
   SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
@@ -10833,7 +10731,7 @@ var SpanKind;
   SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
 })(SpanKind || (SpanKind = {}));
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace/status.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/status.js
 var SpanStatusCode;
 (function(SpanStatusCode2) {
   SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
@@ -10841,99 +10739,112 @@ var SpanStatusCode;
   SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
 })(SpanStatusCode || (SpanStatusCode = {}));
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/context-api.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context-api.js
 var context = ContextAPI.getInstance();
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
-var NoopMeterProvider = (
-  /** @class */
-  function() {
-    function NoopMeterProvider2() {
-    }
-    NoopMeterProvider2.prototype.getMeter = function(_name, _version, _options) {
-      return NOOP_METER;
-    };
-    return NoopMeterProvider2;
-  }()
-);
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
+var NoopMeterProvider = class {
+  getMeter(_name, _version, _options) {
+    return NOOP_METER;
+  }
+};
 var NOOP_METER_PROVIDER = new NoopMeterProvider();
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/metrics.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/metrics.js
 var API_NAME3 = "metrics";
-var MetricsAPI = (
-  /** @class */
-  function() {
-    function MetricsAPI2() {
+var MetricsAPI = class _MetricsAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+  }
+  /** Get the singleton instance of the Metrics API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _MetricsAPI();
     }
-    MetricsAPI2.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new MetricsAPI2();
-      }
-      return this._instance;
-    };
-    MetricsAPI2.prototype.setGlobalMeterProvider = function(provider) {
-      return registerGlobal(API_NAME3, provider, DiagAPI.instance());
-    };
-    MetricsAPI2.prototype.getMeterProvider = function() {
-      return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
-    };
-    MetricsAPI2.prototype.getMeter = function(name, version, options) {
-      return this.getMeterProvider().getMeter(name, version, options);
-    };
-    MetricsAPI2.prototype.disable = function() {
-      unregisterGlobal(API_NAME3, DiagAPI.instance());
-    };
-    return MetricsAPI2;
-  }()
-);
+    return this._instance;
+  }
+  /**
+   * Set the current global meter provider.
+   * Returns true if the meter provider was successfully registered, else false.
+   */
+  setGlobalMeterProvider(provider) {
+    return registerGlobal(API_NAME3, provider, DiagAPI.instance());
+  }
+  /**
+   * Returns the global meter provider.
+   */
+  getMeterProvider() {
+    return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
+  }
+  /**
+   * Returns a meter from the global meter provider.
+   */
+  getMeter(name, version, options) {
+    return this.getMeterProvider().getMeter(name, version, options);
+  }
+  /** Remove the global meter provider */
+  disable() {
+    unregisterGlobal(API_NAME3, DiagAPI.instance());
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/metrics-api.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/metrics-api.js
 var metrics = MetricsAPI.getInstance();
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/api/trace.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/trace.js
 var API_NAME4 = "trace";
-var TraceAPI = (
-  /** @class */
-  function() {
-    function TraceAPI2() {
-      this._proxyTracerProvider = new ProxyTracerProvider();
-      this.wrapSpanContext = wrapSpanContext;
-      this.isSpanContextValid = isSpanContextValid;
-      this.deleteSpan = deleteSpan;
-      this.getSpan = getSpan;
-      this.getActiveSpan = getActiveSpan;
-      this.getSpanContext = getSpanContext;
-      this.setSpan = setSpan;
-      this.setSpanContext = setSpanContext;
-    }
-    TraceAPI2.getInstance = function() {
-      if (!this._instance) {
-        this._instance = new TraceAPI2();
-      }
-      return this._instance;
-    };
-    TraceAPI2.prototype.setGlobalTracerProvider = function(provider) {
-      var success = registerGlobal(API_NAME4, this._proxyTracerProvider, DiagAPI.instance());
-      if (success) {
-        this._proxyTracerProvider.setDelegate(provider);
-      }
-      return success;
-    };
-    TraceAPI2.prototype.getTracerProvider = function() {
-      return getGlobal(API_NAME4) || this._proxyTracerProvider;
-    };
-    TraceAPI2.prototype.getTracer = function(name, version) {
-      return this.getTracerProvider().getTracer(name, version);
-    };
-    TraceAPI2.prototype.disable = function() {
-      unregisterGlobal(API_NAME4, DiagAPI.instance());
-      this._proxyTracerProvider = new ProxyTracerProvider();
-    };
-    return TraceAPI2;
-  }()
-);
+var TraceAPI = class _TraceAPI {
+  /** Empty private constructor prevents end users from constructing a new instance of the API */
+  constructor() {
+    this._proxyTracerProvider = new ProxyTracerProvider();
+    this.wrapSpanContext = wrapSpanContext;
+    this.isSpanContextValid = isSpanContextValid;
+    this.deleteSpan = deleteSpan;
+    this.getSpan = getSpan;
+    this.getActiveSpan = getActiveSpan;
+    this.getSpanContext = getSpanContext;
+    this.setSpan = setSpan;
+    this.setSpanContext = setSpanContext;
+  }
+  /** Get the singleton instance of the Trace API */
+  static getInstance() {
+    if (!this._instance) {
+      this._instance = new _TraceAPI();
+    }
+    return this._instance;
+  }
+  /**
+   * Set the current global tracer.
+   *
+   * @returns true if the tracer provider was successfully registered, else false
+   */
+  setGlobalTracerProvider(provider) {
+    const success = registerGlobal(API_NAME4, this._proxyTracerProvider, DiagAPI.instance());
+    if (success) {
+      this._proxyTracerProvider.setDelegate(provider);
+    }
+    return success;
+  }
+  /**
+   * Returns the global tracer provider.
+   */
+  getTracerProvider() {
+    return getGlobal(API_NAME4) || this._proxyTracerProvider;
+  }
+  /**
+   * Returns a tracer from the global tracer provider.
+   */
+  getTracer(name, version) {
+    return this.getTracerProvider().getTracer(name, version);
+  }
+  /** Remove the global tracer provider */
+  disable() {
+    unregisterGlobal(API_NAME4, DiagAPI.instance());
+    this._proxyTracerProvider = new ProxyTracerProvider();
+  }
+};
 
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/esm/trace-api.js
+// ../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace-api.js
 var trace = TraceAPI.getInstance();
 function getTracer(name) {
   return trace.getTracer(name);
@@ -16430,9 +16341,13 @@ function deserialiseSnapshot(serialised) {
 }
 
 // src/mollifier/buffer.ts
-var ACK_GRACE_TTL_SECONDS = 30;
-function mollifierReconnectDelayMs(times, random = Math.random) {
-  const base = Math.min(times * 50, 1e3);
+var DEFAULT_ACK_GRACE_TTL_SECONDS = 30;
+var DEFAULT_RECONNECT_STEP_MS = 50;
+var DEFAULT_RECONNECT_MAX_MS = 1e3;
+var DEFAULT_MAX_RETRIES_PER_REQUEST = 20;
+var DRAINING_SET_KEY = "mollifier:draining";
+function mollifierReconnectDelayMs(times, random = Math.random, stepMs = DEFAULT_RECONNECT_STEP_MS, maxMs = DEFAULT_RECONNECT_MAX_MS) {
+  const base = Math.min(times * stepMs, maxMs);
   const half = Math.floor(base / 2);
   return half + Math.round(random() * (base - half));
 }
@@ -16449,15 +16364,19 @@ function makeIdempotencyClaimKey(input) {
 var MollifierBuffer = class {
   redis;
   logger;
+  ackGraceTtlSeconds;
   constructor(options) {
     this.logger = options.logger ?? new logger$1.Logger("MollifierBuffer", "debug");
+    this.ackGraceTtlSeconds = options.ackGraceTtlSeconds ?? DEFAULT_ACK_GRACE_TTL_SECONDS;
+    const reconnectStepMs = options.reconnectStepMs ?? DEFAULT_RECONNECT_STEP_MS;
+    const reconnectMaxMs = options.reconnectMaxMs ?? DEFAULT_RECONNECT_MAX_MS;
     this.redis = createRedisClient(
       {
         ...options.redisOptions,
         retryStrategy(times) {
-          return mollifierReconnectDelayMs(times);
+          return mollifierReconnectDelayMs(times, Math.random, reconnectStepMs, reconnectMaxMs);
         },
-        maxRetriesPerRequest: 20
+        maxRetriesPerRequest: options.maxRetriesPerRequest ?? DEFAULT_MAX_RETRIES_PER_REQUEST
       },
       {
         onError: (error) => {
@@ -16514,6 +16433,7 @@ var MollifierBuffer = class {
     const encoded = await this.redis.popAndMarkDraining(
       queueKey,
       orgsKey,
+      DRAINING_SET_KEY,
       entryPrefix,
       envId,
       "mollifier:org-envs:"
@@ -16771,13 +16691,16 @@ var MollifierBuffer = class {
   async ack(runId) {
     await this.redis.ackMollifierEntry(
       `mollifier:entries:${runId}`,
-      String(ACK_GRACE_TTL_SECONDS)
+      DRAINING_SET_KEY,
+      String(this.ackGraceTtlSeconds),
+      runId
     );
   }
   async requeue(runId) {
     await this.redis.requeueMollifierEntry(
       `mollifier:entries:${runId}`,
       "mollifier:orgs",
+      DRAINING_SET_KEY,
       "mollifier:queue:",
       runId,
       "mollifier:org-envs:"
@@ -16792,10 +16715,36 @@ var MollifierBuffer = class {
   async fail(runId, error) {
     const result = await this.redis.failMollifierEntry(
       `mollifier:entries:${runId}`,
-      JSON.stringify(error)
+      DRAINING_SET_KEY,
+      JSON.stringify(error),
+      runId
     );
     return result === 1;
   }
+  // Observability-only: number of entries currently in DRAINING state
+  // (popped, not yet acked/failed/requeued). The gauge in the webapp
+  // drainer worker polls this on a short interval and emits it as
+  // `mollifier.draining.current` for ops dashboards and post-crash
+  // forensics. Cheap (single ZCARD).
+  async getDrainingCount() {
+    return this.redis.zcard(DRAINING_SET_KEY);
+  }
+  // Observability-only: list runIds that have been DRAINING longer than
+  // `olderThanMs` (i.e. popped before `now - olderThanMs`). Bounded by
+  // `limit` to keep the result set tractable when something has gone
+  // very wrong. ZRANGEBYSCORE is O(log N + K). Score is the pop wall-clock
+  // in milliseconds as written by the popAndMarkDraining Lua.
+  async listStaleDraining(olderThanMs, limit) {
+    const maxScore = Date.now() - Math.max(0, olderThanMs);
+    return this.redis.zrangebyscore(
+      DRAINING_SET_KEY,
+      "-inf",
+      String(maxScore),
+      "LIMIT",
+      0,
+      Math.max(0, limit)
+    );
+  }
   // Returns Redis-side TTL on the entry hash. Returns -1 for entries
   // with no TTL — the steady state under the current design, where
   // entries persist until drainer ack/fail. The ack grace TTL (30s
@@ -16896,10 +16845,11 @@ var MollifierBuffer = class {
       `
     });
     this.redis.defineCommand("requeueMollifierEntry", {
-      numberOfKeys: 2,
+      numberOfKeys: 3,
       lua: `
         local entryKey = KEYS[1]
         local orgsKey = KEYS[2]
+        local drainingSetKey = KEYS[3]
         local queuePrefix = ARGV[1]
         local runId = ARGV[2]
         local orgEnvsPrefix = ARGV[3]
@@ -16927,18 +16877,31 @@ var MollifierBuffer = class {
           redis.call('SADD', orgsKey, orgId)
           redis.call('SADD', orgEnvsPrefix .. orgId, envId)
         end
+        -- Observability-only: leaving DRAINING state, so drop the
+        -- entry from the draining-tracker set. ZREM on absent member
+        -- is a no-op.
+        redis.call('ZREM', drainingSetKey, runId)
         return 1
       `
     });
     this.redis.defineCommand("popAndMarkDraining", {
-      numberOfKeys: 2,
+      numberOfKeys: 3,
       lua: `
         local queueKey = KEYS[1]
         local orgsKey = KEYS[2]
+        local drainingSetKey = KEYS[3]
         local entryPrefix = ARGV[1]
         local envId = ARGV[2]
         local orgEnvsPrefix = ARGV[3]
 
+        -- Wall-clock millis used as the ZADD score on the draining-tracker
+        -- set. Computed once per script invocation so all observers see
+        -- the same pop instant. redis.call('TIME') is deterministic per
+        -- script execution (Lua sees it as a single read), satisfying the
+        -- write-determinism contract on replicas/AOF replay.
+        local timeArr = redis.call('TIME')
+        local nowMs = tonumber(timeArr[1]) * 1000 + math.floor(tonumber(timeArr[2]) / 1000)
+
         -- Helper: prune org-level membership when an env's queue empties.
         -- Called only from the success branch where we know orgId from the
         -- popped entry. The no-runId branch below can't reach this because
@@ -16971,6 +16934,14 @@ var MollifierBuffer = class {
           local entryKey = entryPrefix .. runId
           if redis.call('EXISTS', entryKey) == 1 then
             redis.call('HSET', entryKey, 'status', 'DRAINING')
+            -- Observability-only: track the runId in the draining set
+            -- with the pop wall-clock as score. Acked/failed/requeued
+            -- in the corresponding Lua scripts. The set is NOT
+            -- load-bearing for correctness \u2014 the per-entry hash carries
+            -- status \u2014 so a missed ZREM on a partial Lua execution is
+            -- recoverable via the stale-sweep + entry hash, not a
+            -- correctness bug.
+            redis.call('ZADD', drainingSetKey, nowMs, runId)
             local raw = redis.call('HGETALL', entryKey)
             local result = {}
             for i = 1, #raw, 2 do
@@ -17208,10 +17179,18 @@ var MollifierBuffer = class {
       `
     });
     this.redis.defineCommand("ackMollifierEntry", {
-      numberOfKeys: 1,
+      numberOfKeys: 2,
       lua: `
         local entryKey = KEYS[1]
+        local drainingSetKey = KEYS[2]
         local graceTtlSeconds = tonumber(ARGV[1])
+        local runId = ARGV[2]
+
+        -- Always ZREM from the draining-tracker \u2014 even if the entry hash
+        -- has been concurrently torn down, the runId might still be in
+        -- the set (e.g. fail() ran first and cleared the hash but a
+        -- delayed ack races in). Idempotent: ZREM on absent is a no-op.
+        redis.call('ZREM', drainingSetKey, runId)
 
         -- Guard: never create a partial entry. If the hash is gone between
         -- pop and ack (concurrent fail or eviction \u2014 QUEUED entries carry
@@ -17234,10 +17213,17 @@ var MollifierBuffer = class {
       `
     });
     this.redis.defineCommand("failMollifierEntry", {
-      numberOfKeys: 1,
+      numberOfKeys: 2,
       lua: `
         local entryKey = KEYS[1]
+        local drainingSetKey = KEYS[2]
         local errorPayload = ARGV[1]
+        local runId = ARGV[2]
+
+        -- Always ZREM from the draining-tracker (idempotent on absent).
+        -- Mirrors ack: the runId may be in the set even if the entry hash
+        -- has been raced away.
+        redis.call('ZREM', drainingSetKey, runId)
 
         -- Guard: nothing to mark FAILED if the hash is gone (concurrent
         -- ack/manual cleanup). Returning 0 lets the caller distinguish
@@ -17308,8 +17294,11 @@ var MollifierDrainer = class {
   isRetryable;
   pollIntervalMs;
   maxOrgsPerTick;
+  drainBatchSize;
+  concurrency;
+  maxBackoffMs;
+  backoffFloorMs;
   logger;
-  limit;
   // Rotation state. `orgCursor` advances through the active-orgs list.
   // Each org has its own internal cursor in `perOrgEnvCursors` for
   // cycling through that org's envs. Both reset on `start()`.
@@ -17326,8 +17315,11 @@ var MollifierDrainer = class {
     this.isRetryable = options.isRetryable;
     this.pollIntervalMs = options.pollIntervalMs ?? 100;
     this.maxOrgsPerTick = options.maxOrgsPerTick ?? 500;
+    this.drainBatchSize = Math.max(1, options.drainBatchSize ?? 1);
+    this.concurrency = Math.max(1, options.concurrency);
+    this.maxBackoffMs = options.maxBackoffMs ?? 5e3;
+    this.backoffFloorMs = Math.max(1, options.backoffFloorMs ?? 100);
     this.logger = options.logger ?? new logger$1.Logger("MollifierDrainer", "debug");
-    this.limit = pLimit(options.concurrency);
   }
   async runOnce() {
     const orgs = await this.buffer.listOrgs();
@@ -17344,15 +17336,64 @@ var MollifierDrainer = class {
       const envId = this.pickEnvForOrg(orgId, envsForOrg);
       targets.push(envId);
     }
-    const inflight = [];
-    for (const envId of targets) {
-      inflight.push(this.limit(() => this.processOneFromEnv(envId)));
-    }
-    const results = await Promise.all(inflight);
-    return {
-      drained: results.filter((r) => r === "drained").length,
-      failed: results.filter((r) => r === "failed").length
+    if (targets.length === 0) return { drained: 0, failed: 0 };
+    const remaining = /* @__PURE__ */ new Map();
+    const skip = /* @__PURE__ */ new Set();
+    for (const envId of targets) remaining.set(envId, this.drainBatchSize);
+    let cursor = 0;
+    const pickNextEnv = () => {
+      for (let i = 0; i < targets.length; i++) {
+        const idx = (cursor + i) % targets.length;
+        const envId = targets[idx];
+        if (skip.has(envId)) continue;
+        const r = remaining.get(envId) ?? 0;
+        if (r > 0) {
+          remaining.set(envId, r - 1);
+          cursor = (idx + 1) % targets.length;
+          return envId;
+        }
+      }
+      return null;
+    };
+    let drained = 0;
+    let failed = 0;
+    const worker = async () => {
+      while (true) {
+        const envId = pickNextEnv();
+        if (envId === null) return;
+        let entry;
+        try {
+          entry = await this.buffer.pop(envId);
+        } catch (err) {
+          this.logger.error("MollifierDrainer.pop failed", { envId, err });
+          if (!skip.has(envId)) {
+            skip.add(envId);
+            failed += 1;
+          }
+          continue;
+        }
+        if (!entry) {
+          skip.add(envId);
+          continue;
+        }
+        try {
+          const outcome = await this.processEntry(entry);
+          if (outcome === "drained") drained += 1;
+          else failed += 1;
+        } catch (err) {
+          this.logger.error("MollifierDrainer.processEntry failed", {
+            envId,
+            runId: entry.runId,
+            err
+          });
+          failed += 1;
+        }
+      }
     };
+    const totalBudget = targets.length * this.drainBatchSize;
+    const workerCount = Math.min(this.concurrency, totalBudget);
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    return { drained, failed };
   }
   start() {
     if (this.isRunning) return;
@@ -17426,8 +17467,8 @@ var MollifierDrainer = class {
   // brief blip while preventing a tight retry loop during a long Redis
   // outage. 1 → 200ms, 2 → 400ms, 3 → 800ms, 4 → 1.6s, 5 → 3.2s, 6+ → 5s.
   backoffMs(consecutiveErrors) {
-    const base = Math.max(this.pollIntervalMs, 100);
-    const capped = Math.min(base * 2 ** (consecutiveErrors - 1), 5e3);
+    const base = Math.max(this.pollIntervalMs, this.backoffFloorMs);
+    const capped = Math.min(base * 2 ** (consecutiveErrors - 1), this.maxBackoffMs);
     return capped;
   }
   delay(ms) {
@@ -17458,31 +17499,6 @@ var MollifierDrainer = class {
     this.perOrgEnvCursors.set(orgId, (cursor + 1) % sorted.length);
     return sorted[idx];
   }
-  // A failure for one env (e.g. a Redis hiccup mid-batch in `pop`, or in
-  // `requeue`/`fail` during error recovery inside `processEntry`) must not
-  // poison the rest of the batch — `Promise.all` would otherwise reject and
-  // bubble all the way to `loop()`. Catch both stages here so the failed env
-  // is just counted as "failed" for this tick and we move on.
-  async processOneFromEnv(envId) {
-    let entry;
-    try {
-      entry = await this.buffer.pop(envId);
-    } catch (err) {
-      this.logger.error("MollifierDrainer.pop failed", { envId, err });
-      return "failed";
-    }
-    if (!entry) return "empty";
-    try {
-      return await this.processEntry(entry);
-    } catch (err) {
-      this.logger.error("MollifierDrainer.processEntry failed", {
-        envId,
-        runId: entry.runId,
-        err
-      });
-      return "failed";
-    }
-  }
   async processEntry(entry) {
     try {
       const payload = deserialiseSnapshot(entry.payload);