@trigger.dev/redis-worker 4.5.0-rc.3 → 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);
+    };
+    self2.createComponentLogger = (options) => {
+      return new DiagComponentLogger(options);
     };
-    return DiagAPI2;
-  }()
-);
+    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;
-  }()
-);
-
-// ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/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;
-  }()
-);
+    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.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+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);
@@ -16382,6 +16293,7 @@ var stringToDate = zod.z.string().transform((v, ctx) => {
   }
   return d;
 });
+var stringToBool = zod.z.union([zod.z.literal("true"), zod.z.literal("false")]).transform((v) => v === "true");
 var stringToError = zod.z.string().transform((v, ctx) => {
   try {
     return BufferEntryError.parse(JSON.parse(v));
@@ -16398,6 +16310,27 @@ var BufferEntrySchema = zod.z.object({
   status: BufferEntryStatus,
   attempts: stringToInt,
   createdAt: stringToDate,
+  // Microsecond epoch of accept time, kept as a hash field for dwell
+  // metrics. Not a queue sort key (the queue is a FIFO LIST). Defaulted
+  // so an entry written by an accept Lua predating this field — or one
+  // surviving across the deploy that introduced it — still parses instead
+  // of being silently dropped on pop.
+  createdAtMicros: stringToInt.default("0"),
+  // Drainer-ack flag: `true` once the drainer has materialised this run
+  // into PG. The hash persists for a short grace TTL after ack so direct
+  // reads (retrieve, trace, etc.) still resolve while PG replica lag
+  // settles. Absent on pre-ack entries.
+  materialised: stringToBool.default("false"),
+  // Denormalised pointer to the Redis idempotency lookup key (set when
+  // the run was accepted with an idempotency key, empty otherwise). The
+  // ack Lua reads this to DEL the lookup atomically with marking the
+  // entry materialised.
+  idempotencyLookupKey: zod.z.string().optional().default(""),
+  // Optimistic-lock counter for the snapshot's `metadata` field.
+  // Incremented atomically by the CAS metadata Lua. Matches the
+  // semantic of `TaskRun.metadataVersion` on the PG side (which the
+  // UpdateMetadataService uses for the same retry-on-conflict pattern).
+  metadataVersion: stringToInt.default("0"),
   lastError: stringToError.optional()
 });
 function serialiseSnapshot(snapshot) {
@@ -16408,21 +16341,42 @@ function deserialiseSnapshot(serialised) {
 }
 
 // src/mollifier/buffer.ts
+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));
+}
+function encodeKeyPart(value) {
+  return Buffer.from(value, "utf8").toString("base64url");
+}
+function idempotencyLookupKeyFor(input) {
+  return `mollifier:idempotency:${encodeKeyPart(input.envId)}:${encodeKeyPart(input.taskIdentifier)}:${encodeKeyPart(input.idempotencyKey)}`;
+}
+var PENDING_PREFIX = "pending:";
+function makeIdempotencyClaimKey(input) {
+  return `mollifier:claim:${encodeKeyPart(input.envId)}:${encodeKeyPart(input.taskIdentifier)}:${encodeKeyPart(input.idempotencyKey)}`;
+}
 var MollifierBuffer = class {
   redis;
-  entryTtlSeconds;
   logger;
+  ackGraceTtlSeconds;
   constructor(options) {
-    this.entryTtlSeconds = options.entryTtlSeconds;
     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) {
-          const delay = Math.min(times * 50, 1e3);
-          return delay;
+          return mollifierReconnectDelayMs(times, Math.random, reconnectStepMs, reconnectMaxMs);
         },
-        maxRetriesPerRequest: 20
+        maxRetriesPerRequest: options.maxRetriesPerRequest ?? DEFAULT_MAX_RETRIES_PER_REQUEST
       },
       {
         onError: (error) => {
@@ -16432,14 +16386,26 @@ var MollifierBuffer = class {
     );
     this.#registerCommands();
   }
-  // Returns true if the entry was newly written; false if a duplicate runId
-  // was already buffered (idempotent no-op). Callers can use the boolean to
-  // record a duplicate-accept metric without affecting buffer state.
+  // Three outcomes:
+  //   - { kind: "accepted" } — entry was newly written.
+  //   - { kind: "duplicate_run_id" } — runId was already buffered (idempotent
+  //     no-op, same semantic as the previous boolean-false return).
+  //   - { kind: "duplicate_idempotency", existingRunId } — the (env, task,
+  //     idempotencyKey) tuple was already bound to another buffered run.
+  //     The Lua's atomic SETNX is the race-winner; the second caller gets
+  //     the winner's runId so it can return that as the trigger response.
   async accept(input) {
     const entryKey = `mollifier:entries:${input.runId}`;
     const queueKey = `mollifier:queue:${input.envId}`;
     const orgsKey = "mollifier:orgs";
-    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const nowMs = Date.now();
+    const createdAt = new Date(nowMs).toISOString();
+    const createdAtMicros = nowMs * 1e3;
+    const idempotencyLookupKey = input.idempotencyKey && input.taskIdentifier ? idempotencyLookupKeyFor({
+      envId: input.envId,
+      taskIdentifier: input.taskIdentifier,
+      idempotencyKey: input.idempotencyKey
+    }) : "";
     const result = await this.redis.acceptMollifierEntry(
       entryKey,
       queueKey,
@@ -16449,10 +16415,16 @@ var MollifierBuffer = class {
       input.orgId,
       input.payload,
       createdAt,
-      String(this.entryTtlSeconds),
-      "mollifier:org-envs:"
+      String(createdAtMicros),
+      "mollifier:org-envs:",
+      idempotencyLookupKey,
+      "mollifier:entries:"
     );
-    return result === 1;
+    if (typeof result === "string" && result.length > 0) {
+      return { kind: "duplicate_idempotency", existingRunId: result };
+    }
+    if (result === 1) return { kind: "accepted" };
+    return { kind: "duplicate_run_id" };
   }
   async pop(envId) {
     const queueKey = `mollifier:queue:${envId}`;
@@ -16461,6 +16433,7 @@ var MollifierBuffer = class {
     const encoded = await this.redis.popAndMarkDraining(
       queueKey,
       orgsKey,
+      DRAINING_SET_KEY,
       entryPrefix,
       envId,
       "mollifier:org-envs:"
@@ -16506,28 +16479,277 @@ var MollifierBuffer = class {
   async listEnvsForOrg(orgId) {
     return this.redis.smembers(`mollifier:org-envs:${orgId}`);
   }
+  // Read-only enumeration of currently-queued entries for a single env.
+  // Used by the stale-sweep to compute per-entry dwell time, so order is
+  // immaterial — LRANGE returns them newest-first (LPUSH head) but the
+  // caller scans the whole window. Non-destructive: the drainer still
+  // RPOPs these entries in FIFO order.
+  //
+  // The entry HGETALLs are issued in a single pipelined batch (one
+  // network round-trip instead of N) — at the stale-sweep's default
+  // maxCount=1000 the serial implementation cost ~1000 RTTs per env,
+  // which dominated sweep wall-time at any meaningful backlog.
+  //
+  // A missing entry (empty hash) is skipped: the drainer's RPOP+DEL of
+  // the entry hash can race our LRANGE→HGETALL window, so a runId on
+  // the queue with no backing hash is an expected concurrency outcome,
+  // not an error.
+  async listEntriesForEnv(envId, maxCount) {
+    if (maxCount <= 0) return [];
+    const runIds = await this.redis.lrange(
+      `mollifier:queue:${envId}`,
+      0,
+      maxCount - 1
+    );
+    if (runIds.length === 0) return [];
+    const pipeline = this.redis.pipeline();
+    for (const runId of runIds) {
+      pipeline.hgetall(`mollifier:entries:${runId}`);
+    }
+    const results = await pipeline.exec();
+    if (!results) return [];
+    const entries = [];
+    for (let i = 0; i < results.length; i++) {
+      const [err, raw] = results[i];
+      if (err) {
+        this.logger.error("MollifierBuffer.listEntriesForEnv: hgetall failed", {
+          runId: runIds[i],
+          err: err.message
+        });
+        continue;
+      }
+      if (!raw || Object.keys(raw).length === 0) continue;
+      const parsed = BufferEntrySchema.safeParse(raw);
+      if (!parsed.success) {
+        this.logger.error("MollifierBuffer.listEntriesForEnv: invalid entry shape", {
+          runId: runIds[i],
+          errors: parsed.error.flatten()
+        });
+        continue;
+      }
+      entries.push(parsed.data);
+    }
+    return entries;
+  }
+  // Atomic snapshot mutation. Used by customer-mutation API endpoints
+  // (tags, metadata-put, reschedule, cancel) when the run is still in
+  // the buffer. Three outcomes:
+  //   - "applied_to_snapshot": entry was QUEUED + not materialised; the
+  //     drainer will read the patched payload on its next pop.
+  //   - "not_found": no entry hash exists for this runId — including a
+  //     FAILED entry, whose hash the drainer-terminal `fail` path DELs.
+  //   - "busy": entry is DRAINING or materialised. The API
+  //     wait-and-bounces through PG.
+  //   - "limit_exceeded": an `append_tags` patch carrying `maxTags` would
+  //     push the deduped tag count over the cap; nothing is written.
+  async mutateSnapshot(runId, patch) {
+    const result = await this.redis.mutateMollifierSnapshot(
+      `mollifier:entries:${runId}`,
+      JSON.stringify(patch)
+    );
+    if (result === "applied_to_snapshot" || result === "not_found" || result === "busy" || result === "limit_exceeded") {
+      return result;
+    }
+    throw new Error(`MollifierBuffer.mutateSnapshot: unexpected Lua return value: ${result}`);
+  }
+  // Optimistic compare-and-swap on the snapshot's metadata. Caller reads
+  // the current metadataVersion via getEntry, applies operations in JS via
+  // `applyMetadataOperations`, then calls this with the new metadata + the
+  // expected version. Lua refuses if the version has moved (caller retries
+  // up to N times). Mirrors the PG-side `UpdateMetadataService` retry
+  // loop so concurrent increment/append operations don't lose deltas.
+  async casSetMetadata(input) {
+    const entryKey = `mollifier:entries:${input.runId}`;
+    const raw = await this.redis.casSetMollifierMetadata(
+      entryKey,
+      String(input.expectedVersion),
+      input.newMetadata,
+      input.newMetadataType
+    );
+    if (raw === "not_found") return { kind: "not_found" };
+    if (raw === "busy") return { kind: "busy" };
+    if (raw.startsWith("conflict:")) {
+      return { kind: "version_conflict", currentVersion: Number(raw.slice("conflict:".length)) };
+    }
+    if (raw.startsWith("applied:")) {
+      return { kind: "applied", newVersion: Number(raw.slice("applied:".length)) };
+    }
+    throw new Error(`MollifierBuffer.casSetMetadata: unexpected Lua return: ${raw}`);
+  }
+  // Atomic pre-gate claim on a (env, task, idempotencyKey) tuple. One
+  // call across both PG and buffer paths serialises through this claim;
+  // closes the race the buffer-side SETNX leaves open during the
+  // gate-transition burst window.
+  //
+  // The caller supplies an opaque `token` (UUID) on claim. The same token
+  // MUST be passed to `publishClaim` / `releaseClaim`, which compare-and-
+  // act so a late release from a previous claimant whose TTL expired
+  // cannot erase a new owner's claim.
+  //
+  // - "claimed": we now own the claim, the caller proceeds with the
+  //   trigger pipeline and must `publishClaim` on success or
+  //   `releaseClaim` on failure.
+  // - "pending": another trigger owns the claim and hasn't published
+  //   yet; the caller should poll.
+  // - "resolved": the claim already holds a runId; the caller can
+  //   return that runId as a cached hit.
+  async claimIdempotency(input) {
+    const claimKey = makeIdempotencyClaimKey(input);
+    const raw = await this.redis.claimMollifierIdempotency(
+      claimKey,
+      `${PENDING_PREFIX}${input.token}`,
+      PENDING_PREFIX,
+      String(input.ttlSeconds)
+    );
+    if (raw === "claimed") return { kind: "claimed" };
+    if (raw === "pending") return { kind: "pending" };
+    if (raw.startsWith("resolved:")) {
+      return { kind: "resolved", runId: raw.slice("resolved:".length) };
+    }
+    throw new Error(`MollifierBuffer.claimIdempotency: unexpected return: ${raw}`);
+  }
+  // Publish the winning runId to the claim so subsequent claimants /
+  // waiters see "resolved". TTL bounded by the customer's
+  // `idempotencyKeyExpiresAt` minus now; caller computes.
+  //
+  // Compare-and-set on the caller's token: if the current value isn't
+  // our pending marker (TTL expired and another claimant moved in, or
+  // someone else already published), the publish is a no-op. The caller
+  // can treat any such case as "we lost the claim" and re-read.
+  // Returns true if we published; false if the claim slot was no longer
+  // ours.
+  async publishClaim(input) {
+    const claimKey = makeIdempotencyClaimKey(input);
+    const result = await this.redis.publishMollifierClaim(
+      claimKey,
+      `${PENDING_PREFIX}${input.token}`,
+      input.runId,
+      String(input.ttlSeconds)
+    );
+    return result === 1;
+  }
+  // Release the claim on pipeline error so waiters can re-claim and
+  // retry. Idempotent.
+  //
+  // Compare-and-delete on the caller's token: only deletes if the
+  // current value is exactly our pending marker. A late release from a
+  // claimant whose TTL expired is a no-op, so a new owner's claim is
+  // never wiped by a slow predecessor.
+  async releaseClaim(input) {
+    const claimKey = makeIdempotencyClaimKey(input);
+    await this.redis.releaseMollifierClaim(
+      claimKey,
+      `${PENDING_PREFIX}${input.token}`
+    );
+  }
+  // Read the current claim value, used by the wait/poll loop on losers
+  // to detect "pending" → "resolved" transitions and timeouts.
+  async readClaim(input) {
+    const claimKey = makeIdempotencyClaimKey(input);
+    const value = await this.redis.get(claimKey);
+    if (value === null) return null;
+    if (value.startsWith(PENDING_PREFIX)) return { kind: "pending" };
+    return { kind: "resolved", runId: value };
+  }
+  // Resolve a buffered run by (env, task, idempotencyKey) tuple. Used by
+  // `IdempotencyKeyConcern.handleTriggerRequest` after the PG check
+  // misses — same key may belong to a buffered run waiting to drain. The
+  // lookup self-heals: if the lookup points at an entry hash that's gone,
+  // we clear the lookup and report a miss. The clear is a compare-and-
+  // delete (only if the key still holds the stale runId we observed) so a
+  // fresh accept that rebinds the key between our GET and DEL isn't wiped.
+  async lookupIdempotency(input) {
+    const lookupKey = idempotencyLookupKeyFor(input);
+    const runId = await this.redis.get(lookupKey);
+    if (!runId) return null;
+    const entry = await this.getEntry(runId);
+    if (!entry) {
+      await this.redis.delMollifierKeyIfEquals(lookupKey, runId);
+      return null;
+    }
+    return runId;
+  }
+  // Clear the idempotency binding from a buffered run. Used by
+  // `ResetIdempotencyKeyService` alongside the existing PG-side
+  // `updateMany`. Returns the runId that was cleared, or null if no
+  // buffered run held this key.
+  async resetIdempotency(input) {
+    const lookupKey = idempotencyLookupKeyFor(input);
+    const claimKey = makeIdempotencyClaimKey(input);
+    const clearedRunId = await this.redis.resetMollifierIdempotency(
+      lookupKey,
+      "mollifier:entries:",
+      claimKey
+    );
+    return { clearedRunId: clearedRunId.length > 0 ? clearedRunId : null };
+  }
+  // Marks the entry as materialised (PG row written) and resets its TTL to
+  // the grace window. Entry hash persists past ack as a read-fallback
+  // safety net for the brief PG replica-lag window between drainer-side
+  // write and reader-side visibility. Also clears the associated
+  // idempotency lookup if one was set on accept.
   async ack(runId) {
-    await this.redis.del(`mollifier:entries:${runId}`);
+    await this.redis.ackMollifierEntry(
+      `mollifier:entries:${runId}`,
+      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:"
     );
   }
-  // Returns true if the entry transitioned to FAILED; false if the entry no
-  // longer exists (TTL expired between pop and fail). Caller can use the
-  // boolean to skip downstream FAILED handling for ghost entries.
+  // Returns true if a live entry was torn down; false if the entry no
+  // longer existed (a concurrent ack or manual cleanup removed it between
+  // pop and fail — there is no accept-time TTL). Note FAILED is not an
+  // observable state: the Lua marks the hash FAILED then DELs it in the
+  // same atomic script, so a subsequent getEntry returns null. Caller can
+  // use the boolean to skip downstream FAILED handling for ghost entries.
   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
+  // post-materialise) is the only context where this returns a
+  // positive value; tests around the grace TTL still rely on it.
   async getEntryTtlSeconds(runId) {
     return this.redis.ttl(`mollifier:entries:${runId}`);
   }
@@ -16558,8 +16780,10 @@ var MollifierBuffer = class {
         local orgId = ARGV[3]
         local payload = ARGV[4]
         local createdAt = ARGV[5]
-        local ttlSeconds = tonumber(ARGV[6])
+        local createdAtMicros = ARGV[6]
         local orgEnvsPrefix = ARGV[7]
+        local idempotencyLookupKey = ARGV[8] or ''
+        local entryPrefix = ARGV[9]
 
         -- Idempotent: refuse if an entry for this runId already exists in any
         -- state. Caller-side dedup is also enforced via API idempotency keys,
@@ -16568,6 +16792,27 @@ var MollifierBuffer = class {
           return 0
         end
 
+        -- Idempotency-key dedup. If the caller passed a lookup key
+        -- and it's already bound to another buffered run, return the
+        -- winner's runId so the loser's API response can echo it as a
+        -- cached hit. Otherwise SET the lookup (no TTL \u2014 lifecycle is
+        -- paired with the entry hash; drainer ack/fail clear it
+        -- explicitly).
+        if idempotencyLookupKey ~= '' then
+          local existing = redis.call('GET', idempotencyLookupKey)
+          if existing then
+            -- Self-heal: only honour the binding if its entry hash still
+            -- exists. If the entry was evicted (maxmemory) but the lookup
+            -- survived, the binding is stale \u2014 fall through and rebind to
+            -- this run rather than returning a dead runId that would block
+            -- the key indefinitely. Mirrors lookupIdempotency's self-heal.
+            if redis.call('EXISTS', entryPrefix .. existing) == 1 then
+              return existing
+            end
+          end
+          redis.call('SET', idempotencyLookupKey, runId)
+        end
+
         redis.call('HSET', entryKey,
           'runId', runId,
           'envId', envId,
@@ -16575,8 +16820,20 @@ var MollifierBuffer = class {
           'payload', payload,
           'status', 'QUEUED',
           'attempts', '0',
-          'createdAt', createdAt)
-        redis.call('EXPIRE', entryKey, ttlSeconds)
+          'createdAt', createdAt,
+          'createdAtMicros', createdAtMicros,
+          'idempotencyLookupKey', idempotencyLookupKey,
+          'metadataVersion', '0')
+        -- No EXPIRE on the entry hash. Buffer entries persist until the
+        -- drainer ACKs (post-materialise grace) or FAILs them \u2014 the
+        -- drainer is the only recovery mechanism, so silent TTL-based
+        -- eviction would lose runs with no customer-visible signal.
+        -- Memory pressure from an offline drainer is the alertable
+        -- failure mode instead; see _ops/mollifier-ops.md.
+        -- LIST queue: LPUSH at the head, drainer RPOPs from the tail, so
+        -- insertion order == drain order (FIFO). createdAtMicros is kept
+        -- as a hash field for dwell metrics only \u2014 it is no longer a sort
+        -- key now that the buffer has no list/pagination surface.
         redis.call('LPUSH', queueKey, runId)
         -- Org-level membership: maintained atomically with the per-env
         -- queue so the drainer can walk orgs \u2192 envs-for-org and
@@ -16588,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]
@@ -16606,7 +16864,12 @@ var MollifierBuffer = class {
         local nextAttempts = tonumber(currentAttempts or '0') + 1
 
         redis.call('HSET', entryKey, 'status', 'QUEUED', 'attempts', tostring(nextAttempts))
-        redis.call('LPUSH', queuePrefix .. envId, runId)
+        -- Requeue RPUSHes to the tail (the RPOP end) so a transiently
+        -- failed entry pops next rather than going to the back of the
+        -- line behind a fresh backlog. createdAt is immutable across
+        -- retries; the drainer's maxAttempts caps the
+        -- retry loop so a poisoned entry doesn't head-of-line forever.
+        redis.call('RPUSH', queuePrefix .. envId, runId)
         -- Re-track the org/env: pop may have SREM'd them when the queue
         -- last emptied. SADDs are idempotent if the values are still
         -- present.
@@ -16614,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
@@ -16640,11 +16916,13 @@ var MollifierBuffer = class {
           end
         end
 
-        -- Loop to skip orphan queue references \u2014 runIds whose entry hash has
-        -- expired (TTL hit). HSET on a missing key would CREATE a partial
-        -- hash without a TTL, leaking memory. The loop is bounded by queue
-        -- length; entire Lua script remains atomic.
+        -- Loop to skip orphan queue references \u2014 runIds whose entry hash is
+        -- gone (e.g. Redis maxmemory eviction, since QUEUED entries carry
+        -- no TTL of their own). HSET on a missing key would CREATE a
+        -- partial hash without a TTL, leaking memory. The loop is bounded
+        -- by queue length; entire Lua script remains atomic.
         while true do
+          -- RPOP returns the tail member (oldest, FIFO), or false when empty.
           local runId = redis.call('RPOP', queueKey)
           if not runId then
             -- Queue is empty AND we have no entry to read orgId from, so
@@ -16656,40 +16934,334 @@ 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
               result[raw[i]] = raw[i + 1]
             end
             -- Prune org-level membership if this pop drained the queue.
-            -- Atomic with the RPOP above \u2014 a concurrent accept AFTER this
-            -- script will SADD both back along with its LPUSH.
+            -- Atomic with the RPOP above \u2014 a concurrent accept AFTER
+            -- this script will SADD both back along with its LPUSH.
             if redis.call('LLEN', queueKey) == 0 then
               pruneOrgMembership(result['orgId'])
             end
             return cjson.encode(result)
           end
-          -- Orphan queue reference: entry TTL expired while runId was queued.
-          -- Discard the reference and loop to the next.
+          -- Orphan queue reference: entry hash gone (evicted) while runId
+          -- was queued. Discard the reference and loop to the next.
         end
       `
     });
-    this.redis.defineCommand("failMollifierEntry", {
+    this.redis.defineCommand("casSetMollifierMetadata", {
+      numberOfKeys: 1,
+      lua: `
+        local entryKey = KEYS[1]
+        local expectedVersion = tonumber(ARGV[1])
+        local newMetadata = ARGV[2]
+        local newMetadataType = ARGV[3]
+
+        if redis.call('EXISTS', entryKey) == 0 then
+          return 'not_found'
+        end
+
+        local status = redis.call('HGET', entryKey, 'status')
+        local materialised = redis.call('HGET', entryKey, 'materialised')
+        if status ~= 'QUEUED' or materialised == 'true' then
+          return 'busy'
+        end
+
+        local currentVersionStr = redis.call('HGET', entryKey, 'metadataVersion') or '0'
+        local currentVersion = tonumber(currentVersionStr) or 0
+        if currentVersion ~= expectedVersion then
+          return 'conflict:' .. tostring(currentVersion)
+        end
+
+        -- Write the new metadata onto the snapshot's payload JSON. We
+        -- keep the rest of the payload intact \u2014 only metadata/metadataType
+        -- change. metadataVersion is denormalised on the hash for cheap
+        -- CAS reads; it's intentionally NOT stored inside the payload
+        -- itself (PG-side metadataVersion is a column, not a JSON field).
+        local payloadJson = redis.call('HGET', entryKey, 'payload')
+        local ok, payload = pcall(cjson.decode, payloadJson)
+        if not ok then return 'busy' end
+        payload.metadata = newMetadata
+        payload.metadataType = newMetadataType
+
+        local newVersion = currentVersion + 1
+        redis.call('HSET', entryKey,
+          'payload', cjson.encode(payload),
+          'metadataVersion', tostring(newVersion))
+        return 'applied:' .. tostring(newVersion)
+      `
+    });
+    this.redis.defineCommand("claimMollifierIdempotency", {
+      numberOfKeys: 1,
+      lua: `
+        local claimKey = KEYS[1]
+        local pendingMarker = ARGV[1]   -- "pending:<caller-token>"
+        local pendingPrefix = ARGV[2]   -- "pending:"
+        local ttl = tonumber(ARGV[3])
+
+        -- SETNX-with-TTL: atomic; only one caller can win.
+        local won = redis.call('SET', claimKey, pendingMarker, 'NX', 'EX', ttl)
+        if won then
+          return 'claimed'
+        end
+
+        local existing = redis.call('GET', claimKey)
+        if not existing then
+          -- The slot expired in the race window between the SET NX
+          -- failing and this GET. It's free now \u2014 claim it so we don't
+          -- string.sub a nil and error out.
+          redis.call('SET', claimKey, pendingMarker, 'EX', ttl)
+          return 'claimed'
+        end
+        -- Any "pending:*" value is a live claim \u2014 the caller-supplied
+        -- token differentiates ownership but is opaque to losers.
+        if string.sub(existing, 1, string.len(pendingPrefix)) == pendingPrefix then
+          return 'pending'
+        end
+        return 'resolved:' .. existing
+      `
+    });
+    this.redis.defineCommand("publishMollifierClaim", {
+      numberOfKeys: 1,
+      lua: `
+        local claimKey = KEYS[1]
+        local ownerMarker = ARGV[1]   -- "pending:<our-token>"
+        local runId = ARGV[2]
+        local ttl = tonumber(ARGV[3])
+
+        local existing = redis.call('GET', claimKey)
+        if existing == ownerMarker then
+          redis.call('SET', claimKey, runId, 'EX', ttl)
+          return 1
+        end
+        return 0
+      `
+    });
+    this.redis.defineCommand("releaseMollifierClaim", {
+      numberOfKeys: 1,
+      lua: `
+        local claimKey = KEYS[1]
+        local ownerMarker = ARGV[1]   -- "pending:<our-token>"
+
+        local existing = redis.call('GET', claimKey)
+        if existing == ownerMarker then
+          redis.call('DEL', claimKey)
+          return 1
+        end
+        return 0
+      `
+    });
+    this.redis.defineCommand("resetMollifierIdempotency", {
+      numberOfKeys: 1,
+      lua: `
+        local lookupKey = KEYS[1]
+        local entryPrefix = ARGV[1]
+        local claimKey = ARGV[2]
+
+        -- Reset reopens the key across BOTH the buffer lookup and the
+        -- cross-store pre-gate claim pointer. Without clearing the claim,
+        -- a resolved/pending claim would keep deduping new triggers for
+        -- the rest of its TTL even though the binding was reset. DEL is
+        -- unconditional \u2014 the claim is gone regardless of whether a
+        -- buffered run currently holds the lookup.
+        redis.call('DEL', claimKey)
+
+        local runId = redis.call('GET', lookupKey)
+        if not runId then
+          return ''
+        end
+
+        local entryKey = entryPrefix .. runId
+        if redis.call('EXISTS', entryKey) == 0 then
+          -- Stale lookup. Lazy cleanup.
+          redis.call('DEL', lookupKey)
+          return ''
+        end
+
+        -- Clear the idempotency fields on the snapshot payload so the
+        -- drainer's eventual engine.trigger call inserts a PG row
+        -- without the key set.
+        local payloadJson = redis.call('HGET', entryKey, 'payload')
+        if payloadJson then
+          local ok, payload = pcall(cjson.decode, payloadJson)
+          if ok then
+            payload.idempotencyKey = cjson.null
+            payload.idempotencyKeyExpiresAt = cjson.null
+            redis.call('HSET', entryKey, 'payload', cjson.encode(payload))
+          end
+        end
+        -- Clear the denormalised lookup pointer on the hash so a later
+        -- ack doesn't try to DEL a key that's already gone.
+        redis.call('HSET', entryKey, 'idempotencyLookupKey', '')
+        redis.call('DEL', lookupKey)
+        return runId
+      `
+    });
+    this.redis.defineCommand("mutateMollifierSnapshot", {
       numberOfKeys: 1,
       lua: `
         local entryKey = KEYS[1]
+        local patchJson = ARGV[1]
+
+        if redis.call('EXISTS', entryKey) == 0 then
+          return 'not_found'
+        end
+
+        local status = redis.call('HGET', entryKey, 'status')
+        local materialised = redis.call('HGET', entryKey, 'materialised')
+        if status ~= 'QUEUED' or materialised == 'true' then
+          return 'busy'
+        end
+
+        local payloadJson = redis.call('HGET', entryKey, 'payload')
+        local ok, payload = pcall(cjson.decode, payloadJson)
+        if not ok then return 'busy' end
+
+        local patch = cjson.decode(patchJson)
+
+        if patch.type == 'append_tags' then
+          -- cjson decode of an absent or empty-array field gives nil or
+          -- an empty table; we rebuild as a dense array. Existing tags
+          -- are preserved; new tags are appended only if not present.
+          local existing = payload.tags or {}
+          local seen = {}
+          local merged = {}
+          for _, t in ipairs(existing) do
+            if not seen[t] then
+              seen[t] = true
+              table.insert(merged, t)
+            end
+          end
+          for _, t in ipairs(patch.tags or {}) do
+            if not seen[t] then
+              seen[t] = true
+              table.insert(merged, t)
+            end
+          end
+          -- Cap the deduped count when the caller supplies a limit, so a
+          -- buffered run can't exceed MAX_TAGS_PER_RUN via the tags API.
+          -- Reject the whole patch (write nothing) rather than truncating.
+          if patch.maxTags ~= nil and #merged > patch.maxTags then
+            return 'limit_exceeded'
+          end
+          payload.tags = merged
+        elseif patch.type == 'set_metadata' then
+          payload.metadata = patch.metadata
+          payload.metadataType = patch.metadataType
+          -- Bump the denormalised metadataVersion so an in-flight
+          -- casSetMetadata (optimistic CAS keyed on this counter) sees
+          -- the concurrent write as a version conflict and retries,
+          -- instead of clobbering it under a now-stale expectedVersion.
+          local currentVersion = tonumber(redis.call('HGET', entryKey, 'metadataVersion') or '0') or 0
+          redis.call('HSET', entryKey, 'metadataVersion', tostring(currentVersion + 1))
+        elseif patch.type == 'set_delay' then
+          payload.delayUntil = patch.delayUntil
+        elseif patch.type == 'mark_cancelled' then
+          payload.cancelledAt = patch.cancelledAt
+          payload.cancelReason = patch.cancelReason
+        else
+          return 'busy'
+        end
+
+        redis.call('HSET', entryKey, 'payload', cjson.encode(payload))
+        return 'applied_to_snapshot'
+      `
+    });
+    this.redis.defineCommand("ackMollifierEntry", {
+      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
+        -- no TTL), the run is gone, nothing to mark materialised.
+        if redis.call('EXISTS', entryKey) == 0 then
+          return 0
+        end
+
+        -- If the entry was accepted with an idempotency key, the lookup
+        -- string was stored on the hash at accept time. Clear it now \u2014
+        -- PG becomes canonical for the key post-materialisation.
+        local lookupKey = redis.call('HGET', entryKey, 'idempotencyLookupKey')
+        if lookupKey and lookupKey ~= '' then
+          redis.call('DEL', lookupKey)
+        end
+
+        redis.call('HSET', entryKey, 'materialised', 'true')
+        redis.call('EXPIRE', entryKey, graceTtlSeconds)
+        return 1
+      `
+    });
+    this.redis.defineCommand("failMollifierEntry", {
+      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: never create a partial entry. If the hash expired between
-        -- pop and fail, the run is gone \u2014 nothing to mark FAILED.
+        -- Guard: nothing to mark FAILED if the hash is gone (concurrent
+        -- ack/manual cleanup). Returning 0 lets the caller distinguish
+        -- "marked failed" from "no-op".
         if redis.call('EXISTS', entryKey) == 0 then
           return 0
         end
 
         redis.call('HSET', entryKey, 'status', 'FAILED', 'lastError', errorPayload)
+
+        -- Terminal-failure contract: the drainer's onTerminalFailure
+        -- callback (see MollifierDrainer.processEntry) has been
+        -- invoked before this fail() and has either written a
+        -- SYSTEM_FAILURE PG row (for both non-retryable AND
+        -- max-attempts-exhausted retryable errors) or chosen to fall
+        -- through (genuinely bad snapshot the engine can't materialise
+        -- a row from). Either way the buffer entry is no longer
+        -- load-bearing here. Clear the idempotency lookup -- PG's
+        -- unique constraint is the canonical dedup mechanism
+        -- post-materialise -- and drop the entry hash so failed runs
+        -- don't accrete forever now that there's no accept-time TTL.
+        local lookupKey = redis.call('HGET', entryKey, 'idempotencyLookupKey')
+        if lookupKey and lookupKey ~= '' then
+          redis.call('DEL', lookupKey)
+        end
+        redis.call('DEL', entryKey)
         return 1
       `
     });
+    this.redis.defineCommand("delMollifierKeyIfEquals", {
+      numberOfKeys: 1,
+      lua: `
+        if redis.call('GET', KEYS[1]) == ARGV[1] then
+          return redis.call('DEL', KEYS[1])
+        end
+        return 0
+      `
+    });
     this.redis.defineCommand("mollifierEvaluateTrip", {
       numberOfKeys: 2,
       lua: `
@@ -16717,12 +17289,16 @@ var MollifierBuffer = class {
 var MollifierDrainer = class {
   buffer;
   handler;
+  onTerminalFailure;
   maxAttempts;
   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()`.
@@ -16734,12 +17310,16 @@ var MollifierDrainer = class {
   constructor(options) {
     this.buffer = options.buffer;
     this.handler = options.handler;
+    this.onTerminalFailure = options.onTerminalFailure;
     this.maxAttempts = options.maxAttempts;
     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();
@@ -16756,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;
@@ -16838,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) {
@@ -16870,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);
@@ -16918,13 +17522,46 @@ var MollifierDrainer = class {
         });
         return "failed";
       }
+      const cause = this.isRetryable(err) ? "max-attempts-exhausted" : "non-retryable";
       const code = err instanceof Error ? err.name : "Unknown";
       const message = err instanceof Error ? err.message : String(err);
+      if (this.onTerminalFailure) {
+        try {
+          await this.onTerminalFailure({
+            runId: entry.runId,
+            envId: entry.envId,
+            orgId: entry.orgId,
+            payload: deserialiseSnapshot(entry.payload),
+            attempts: nextAttempts,
+            createdAt: entry.createdAt,
+            error: { code, message },
+            cause
+          });
+        } catch (writeErr) {
+          if (this.isRetryable(writeErr)) {
+            await this.buffer.requeue(entry.runId);
+            this.logger.warn(
+              "MollifierDrainer: terminal-failure callback retryable; requeued",
+              {
+                runId: entry.runId,
+                attempts: nextAttempts,
+                writeErr
+              }
+            );
+            return "failed";
+          }
+          this.logger.error("MollifierDrainer: terminal-failure callback failed", {
+            runId: entry.runId,
+            writeErr
+          });
+        }
+      }
       await this.buffer.fail(entry.runId, { code, message });
       this.logger.error("MollifierDrainer: terminal failure", {
         runId: entry.runId,
         code,
-        message
+        message,
+        cause
       });
       return "failed";
     }
@@ -16965,7 +17602,9 @@ exports.WorkerQueueManager = WorkerQueueManager;
 exports.createDefaultRetryStrategy = createDefaultRetryStrategy;
 exports.defaultRetryOptions = defaultRetryOptions;
 exports.deserialiseSnapshot = deserialiseSnapshot;
+exports.idempotencyLookupKeyFor = idempotencyLookupKeyFor;
 exports.isAbortError = isAbortError;
+exports.makeIdempotencyClaimKey = makeIdempotencyClaimKey;
 exports.noopTelemetry = noopTelemetry;
 exports.serialiseSnapshot = serialiseSnapshot;
 //# sourceMappingURL=index.cjs.map