@trigger.dev/redis-worker 4.5.0-rc.7 → 4.5.1

package/dist/index.cjs

@@ -9060,7 +9060,7 @@ var require_Redis = __commonJS({
     var lodash_1 = require_lodash3();
     var Deque = require_denque();
     var debug = (0, utils_1.Debug)("redis");
-    var Redis4 = class _Redis extends Commander_1.default {
+    var Redis3 = class _Redis extends Commander_1.default {
       constructor(arg1, arg2, arg3) {
         super();
         this.status = "wait";
@@ -9639,12 +9639,12 @@ var require_Redis = __commonJS({
         }).catch(lodash_1.noop);
       }
     };
-    Redis4.Cluster = cluster_1.default;
-    Redis4.Command = Command_1.default;
-    Redis4.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
-    (0, applyMixin_1.default)(Redis4, events_1.EventEmitter);
-    (0, transaction_1.addTransactionSupport)(Redis4.prototype);
-    exports$1.default = Redis4;
+    Redis3.Cluster = cluster_1.default;
+    Redis3.Command = Command_1.default;
+    Redis3.defaultOptions = RedisOptions_1.DEFAULT_REDIS_OPTIONS;
+    (0, applyMixin_1.default)(Redis3, events_1.EventEmitter);
+    (0, transaction_1.addTransactionSupport)(Redis3.prototype);
+    exports$1.default = Redis3;
   }
 });
 
@@ -9992,6 +9992,37 @@ var SimpleQueue = class {
       throw e;
     }
   }
+  /**
+   * Age (in ms) of the oldest *overdue* message — the oldest item whose scheduled
+   * time has already passed (score <= now). Returns 0 when the queue is empty or
+   * only holds future/delayed or in-flight (future-scored) items.
+   *
+   * Resolves the candidate against the `items` hash so orphaned `queue` entries
+   * (a member whose payload is missing — the same stale state `dequeueItems`
+   * cleans up) don't report a phantom stall for work that can't be dequeued. The
+   * Lua scans due items oldest-first and returns the first score whose payload
+   * still exists.
+   *
+   * This is the generic stall signal: it stays at 0 while a queue drains healthily
+   * and rises only when due work sits undrained (poison block, dead consumer,
+   * backpressure).
+   */
+  async oldestMessageAge() {
+    try {
+      const now = Date.now();
+      const score = Number(await this.redis.getOldestDueScore(`queue`, `items`, now));
+      if (!Number.isFinite(score) || score < 0) {
+        return 0;
+      }
+      return Math.max(0, now - score);
+    } catch (e) {
+      this.logger.error(`SimpleQueue ${this.name}.oldestMessageAge(): error getting oldest age`, {
+        queue: this.name,
+        error: e
+      });
+      return 0;
+    }
+  }
   async getJob(id) {
     const result = await this.redis.getJob(`queue`, `items`, id);
     if (!result) {
@@ -10158,6 +10189,29 @@ var SimpleQueue = class {
         return dequeued
       `
     });
+    this.redis.defineCommand("getOldestDueScore", {
+      numberOfKeys: 2,
+      lua: `
+        local queue = KEYS[1]
+        local items = KEYS[2]
+        local now = tonumber(ARGV[1])
+
+        -- Oldest-first scan of due items, bounded so a long prefix of orphans can't
+        -- make this O(n). Orphans are rare (dequeueItems removes them), so in the
+        -- common case this returns on the first iteration. Read-only: unlike
+        -- dequeueItems we don't ZREM orphans here \u2014 a metric probe must not mutate.
+        local result = redis.call('ZRANGEBYSCORE', queue, '-inf', now, 'WITHSCORES', 'LIMIT', 0, 100)
+
+        for i = 1, #result, 2 do
+          local id = result[i]
+          if redis.call('HEXISTS', items, id) == 1 then
+            return result[i + 1]
+          end
+        end
+
+        return -1
+      `
+    });
     this.redis.defineCommand("getJob", {
       numberOfKeys: 2,
       lua: `
@@ -11402,6 +11456,15 @@ var Worker = class _Worker {
     concurrencyLimitPendingObservableGauge.addCallback(
       this.#updateConcurrencyLimitPendingMetric.bind(this)
     );
+    const oldestMessageAgeObservableGauge = this.meter.createObservableGauge(
+      "redis_worker.queue.oldest_message_age",
+      {
+        description: "Age of the oldest overdue message in the queue",
+        unit: "ms",
+        valueType: ValueType.INT
+      }
+    );
+    oldestMessageAgeObservableGauge.addCallback(this.#updateOldestMessageAgeMetric.bind(this));
   }
   subscriber;
   tracer;
@@ -11430,6 +11493,12 @@ var Worker = class _Worker {
       worker_name: this.options.name
     });
   }
+  async #updateOldestMessageAgeMetric(observableResult) {
+    const oldestMessageAge = await this.queue.oldestMessageAge();
+    observableResult.observe(oldestMessageAge, {
+      worker_name: this.options.name
+    });
+  }
   async #updateConcurrencyLimitActiveMetric(observableResult) {
     for (const [workerId, limiter] of Object.entries(this.limiters)) {
       observableResult.observe(limiter.activeCount, {
@@ -11723,15 +11792,15 @@ var Worker = class _Worker {
               await this.flushBatch(queueItem.job, workerId, limiter);
             }
           } else {
-            limiter(
-              () => this.processItem(queueItem, items.length, workerId, limiter)
-            ).catch((err) => {
-              this.logger.error("Unhandled error in processItem:", {
-                error: err,
-                workerId,
-                item
-              });
-            });
+            limiter(() => this.processItem(queueItem, items.length, workerId, limiter)).catch(
+              (err) => {
+                this.logger.error("Unhandled error in processItem:", {
+                  error: err,
+                  workerId,
+                  item
+                });
+              }
+            );
           }
         }
       } catch (error) {
@@ -11881,13 +11950,25 @@ var Worker = class _Worker {
               attempt: newAttempt
             };
             if (!shouldLogError) {
-              this.logger.info(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+              this.logger.info(
+                `Worker batch item reached max attempts. Moving to DLQ.`,
+                dlqLogAttributes
+              );
             } else if (errorLogLevel === "warn") {
-              this.logger.warn(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+              this.logger.warn(
+                `Worker batch item reached max attempts. Moving to DLQ.`,
+                dlqLogAttributes
+              );
             } else if (errorLogLevel === "info") {
-              this.logger.info(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+              this.logger.info(
+                `Worker batch item reached max attempts. Moving to DLQ.`,
+                dlqLogAttributes
+              );
             } else {
-              this.logger.error(`Worker batch item reached max attempts. Moving to DLQ.`, dlqLogAttributes);
+              this.logger.error(
+                `Worker batch item reached max attempts. Moving to DLQ.`,
+                dlqLogAttributes
+              );
             }
             await this.queue.moveToDeadLetterQueue(item.id, errorMessage);
             continue;
@@ -12644,135 +12725,6 @@ return 1
     });
   }
 };
-var TenantDispatch = class {
-  constructor(options) {
-    this.options = options;
-    this.redis = createRedisClient(options.redis);
-    this.keys = options.keys;
-    this.shardCount = Math.max(1, options.shardCount);
-  }
-  redis;
-  keys;
-  shardCount;
-  /**
-   * Get the dispatch shard ID for a tenant.
-   * Uses jump consistent hash on the tenant ID so each tenant
-   * always maps to exactly one dispatch shard.
-   */
-  getShardForTenant(tenantId) {
-    return serverOnly.jumpHash(tenantId, this.shardCount);
-  }
-  /**
-   * Get eligible tenants from a dispatch shard (Level 1).
-   * Returns tenants ordered by oldest message (lowest score first).
-   */
-  async getTenantsFromShard(shardId, limit = 1e3, maxScore) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    const score = maxScore ?? Date.now();
-    const results = await this.redis.zrangebyscore(
-      dispatchKey,
-      "-inf",
-      score,
-      "WITHSCORES",
-      "LIMIT",
-      0,
-      limit
-    );
-    const tenants = [];
-    for (let i = 0; i < results.length; i += 2) {
-      const tenantId = results[i];
-      const scoreStr = results[i + 1];
-      if (tenantId && scoreStr) {
-        tenants.push({
-          tenantId,
-          score: parseFloat(scoreStr)
-        });
-      }
-    }
-    return tenants;
-  }
-  /**
-   * Get queues for a specific tenant (Level 2).
-   * Returns queues ordered by oldest message (lowest score first).
-   */
-  async getQueuesForTenant(tenantId, limit = 1e3, maxScore) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    const score = maxScore ?? Date.now();
-    const results = await this.redis.zrangebyscore(
-      tenantQueueKey,
-      "-inf",
-      score,
-      "WITHSCORES",
-      "LIMIT",
-      0,
-      limit
-    );
-    const queues = [];
-    for (let i = 0; i < results.length; i += 2) {
-      const queueId = results[i];
-      const scoreStr = results[i + 1];
-      if (queueId && scoreStr) {
-        queues.push({
-          queueId,
-          score: parseFloat(scoreStr),
-          tenantId
-        });
-      }
-    }
-    return queues;
-  }
-  /**
-   * Get the number of tenants in a dispatch shard.
-   */
-  async getShardTenantCount(shardId) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    return await this.redis.zcard(dispatchKey);
-  }
-  /**
-   * Get total tenant count across all dispatch shards.
-   * Note: tenants may appear in multiple shards, so this may overcount.
-   */
-  async getTotalTenantCount() {
-    const counts = await Promise.all(
-      Array.from({ length: this.shardCount }, (_, i) => this.getShardTenantCount(i))
-    );
-    return counts.reduce((sum, count) => sum + count, 0);
-  }
-  /**
-   * Get the number of queues for a tenant.
-   */
-  async getTenantQueueCount(tenantId) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    return await this.redis.zcard(tenantQueueKey);
-  }
-  /**
-   * Remove a tenant from a specific dispatch shard.
-   */
-  async removeTenantFromShard(shardId, tenantId) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    await this.redis.zrem(dispatchKey, tenantId);
-  }
-  /**
-   * Add a tenant to a dispatch shard with the given score.
-   */
-  async addTenantToShard(shardId, tenantId, score) {
-    const dispatchKey = this.keys.dispatchKey(shardId);
-    await this.redis.zadd(dispatchKey, score, tenantId);
-  }
-  /**
-   * Remove a queue from a tenant's queue index.
-   */
-  async removeQueueFromTenant(tenantId, queueId) {
-    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
-    await this.redis.zrem(tenantQueueKey, queueId);
-  }
-  /**
-   * Close the Redis connection.
-   */
-  async close() {
-    await this.redis.quit();
-  }
-};
 
 // src/fair-queue/telemetry.ts
 var FairQueueAttributes = {
@@ -13252,41 +13204,170 @@ var BatchedSpanManager = class {
     }
   }
   /**
-   * Clean up state for a loop when it's stopped.
+   * Clean up state for a loop when it's stopped.
+   */
+  cleanup(loopId) {
+    this.endCurrentSpan(loopId);
+    this.loopStates.delete(loopId);
+  }
+  /**
+   * Clean up all loop states.
+   */
+  cleanupAll() {
+    for (const loopId of this.loopStates.keys()) {
+      this.cleanup(loopId);
+    }
+  }
+};
+var noopSpan = {
+  spanContext: () => ({
+    traceId: "",
+    spanId: "",
+    traceFlags: 0
+  }),
+  setAttribute: () => noopSpan,
+  setAttributes: () => noopSpan,
+  addEvent: () => noopSpan,
+  addLink: () => noopSpan,
+  addLinks: () => noopSpan,
+  setStatus: () => noopSpan,
+  updateName: () => noopSpan,
+  end: () => {
+  },
+  isRecording: () => false,
+  recordException: () => {
+  }
+};
+var noopTelemetry = new FairQueueTelemetry({});
+var TenantDispatch = class {
+  constructor(options) {
+    this.options = options;
+    this.redis = createRedisClient(options.redis);
+    this.keys = options.keys;
+    this.shardCount = Math.max(1, options.shardCount);
+  }
+  redis;
+  keys;
+  shardCount;
+  /**
+   * Get the dispatch shard ID for a tenant.
+   * Uses jump consistent hash on the tenant ID so each tenant
+   * always maps to exactly one dispatch shard.
+   */
+  getShardForTenant(tenantId) {
+    return serverOnly.jumpHash(tenantId, this.shardCount);
+  }
+  /**
+   * Get eligible tenants from a dispatch shard (Level 1).
+   * Returns tenants ordered by oldest message (lowest score first).
+   */
+  async getTenantsFromShard(shardId, limit = 1e3, maxScore) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    const score = maxScore ?? Date.now();
+    const results = await this.redis.zrangebyscore(
+      dispatchKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+    const tenants = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const tenantId = results[i];
+      const scoreStr = results[i + 1];
+      if (tenantId && scoreStr) {
+        tenants.push({
+          tenantId,
+          score: parseFloat(scoreStr)
+        });
+      }
+    }
+    return tenants;
+  }
+  /**
+   * Get queues for a specific tenant (Level 2).
+   * Returns queues ordered by oldest message (lowest score first).
+   */
+  async getQueuesForTenant(tenantId, limit = 1e3, maxScore) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    const score = maxScore ?? Date.now();
+    const results = await this.redis.zrangebyscore(
+      tenantQueueKey,
+      "-inf",
+      score,
+      "WITHSCORES",
+      "LIMIT",
+      0,
+      limit
+    );
+    const queues = [];
+    for (let i = 0; i < results.length; i += 2) {
+      const queueId = results[i];
+      const scoreStr = results[i + 1];
+      if (queueId && scoreStr) {
+        queues.push({
+          queueId,
+          score: parseFloat(scoreStr),
+          tenantId
+        });
+      }
+    }
+    return queues;
+  }
+  /**
+   * Get the number of tenants in a dispatch shard.
+   */
+  async getShardTenantCount(shardId) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    return await this.redis.zcard(dispatchKey);
+  }
+  /**
+   * Get total tenant count across all dispatch shards.
+   * Note: tenants may appear in multiple shards, so this may overcount.
+   */
+  async getTotalTenantCount() {
+    const counts = await Promise.all(
+      Array.from({ length: this.shardCount }, (_, i) => this.getShardTenantCount(i))
+    );
+    return counts.reduce((sum, count) => sum + count, 0);
+  }
+  /**
+   * Get the number of queues for a tenant.
+   */
+  async getTenantQueueCount(tenantId) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    return await this.redis.zcard(tenantQueueKey);
+  }
+  /**
+   * Remove a tenant from a specific dispatch shard.
+   */
+  async removeTenantFromShard(shardId, tenantId) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zrem(dispatchKey, tenantId);
+  }
+  /**
+   * Add a tenant to a dispatch shard with the given score.
    */
-  cleanup(loopId) {
-    this.endCurrentSpan(loopId);
-    this.loopStates.delete(loopId);
+  async addTenantToShard(shardId, tenantId, score) {
+    const dispatchKey = this.keys.dispatchKey(shardId);
+    await this.redis.zadd(dispatchKey, score, tenantId);
   }
   /**
-   * Clean up all loop states.
+   * Remove a queue from a tenant's queue index.
    */
-  cleanupAll() {
-    for (const loopId of this.loopStates.keys()) {
-      this.cleanup(loopId);
-    }
+  async removeQueueFromTenant(tenantId, queueId) {
+    const tenantQueueKey = this.keys.tenantQueueIndexKey(tenantId);
+    await this.redis.zrem(tenantQueueKey, queueId);
   }
-};
-var noopSpan = {
-  spanContext: () => ({
-    traceId: "",
-    spanId: "",
-    traceFlags: 0
-  }),
-  setAttribute: () => noopSpan,
-  setAttributes: () => noopSpan,
-  addEvent: () => noopSpan,
-  addLink: () => noopSpan,
-  addLinks: () => noopSpan,
-  setStatus: () => noopSpan,
-  updateName: () => noopSpan,
-  end: () => {
-  },
-  isRecording: () => false,
-  recordException: () => {
+  /**
+   * Close the Redis connection.
+   */
+  async close() {
+    await this.redis.quit();
   }
 };
-var noopTelemetry = new FairQueueTelemetry({});
 var VisibilityManager = class {
   constructor(options) {
     this.options = options;
@@ -14268,6 +14349,101 @@ var CallbackFairQueueKeyProducer = class extends DefaultFairQueueKeyProducer {
     return this.groupExtractor(groupName, queueId);
   }
 };
+var ExponentialBackoffRetry = class {
+  maxAttempts;
+  options;
+  constructor(options) {
+    this.options = {
+      maxAttempts: options?.maxAttempts ?? 12,
+      factor: options?.factor ?? 2,
+      minTimeoutInMs: options?.minTimeoutInMs ?? 1e3,
+      maxTimeoutInMs: options?.maxTimeoutInMs ?? 36e5,
+      // 1 hour
+      randomize: options?.randomize ?? true
+    };
+    this.maxAttempts = this.options.maxAttempts ?? 12;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    const delay = v3.calculateNextRetryDelay(this.options, attempt);
+    return delay ?? null;
+  }
+};
+var FixedDelayRetry = class {
+  maxAttempts;
+  delayMs;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.delayMs = options.delayMs;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return this.delayMs;
+  }
+};
+var LinearBackoffRetry = class {
+  maxAttempts;
+  baseDelayMs;
+  maxDelayMs;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.baseDelayMs = options.baseDelayMs;
+    this.maxDelayMs = options.maxDelayMs ?? options.baseDelayMs * options.maxAttempts;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    const delay = this.baseDelayMs * attempt;
+    return Math.min(delay, this.maxDelayMs);
+  }
+};
+var NoRetry = class {
+  maxAttempts = 1;
+  getNextDelay(_attempt, _error) {
+    return null;
+  }
+};
+var ImmediateRetry = class {
+  maxAttempts;
+  constructor(maxAttempts) {
+    this.maxAttempts = maxAttempts;
+  }
+  getNextDelay(attempt, _error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return 0;
+  }
+};
+var CustomRetry = class {
+  maxAttempts;
+  calculateDelay;
+  constructor(options) {
+    this.maxAttempts = options.maxAttempts;
+    this.calculateDelay = options.calculateDelay;
+  }
+  getNextDelay(attempt, error) {
+    if (attempt >= this.maxAttempts) {
+      return null;
+    }
+    return this.calculateDelay(attempt, error);
+  }
+};
+var defaultRetryOptions = {
+  maxAttempts: 12,
+  factor: 2,
+  minTimeoutInMs: 1e3,
+  maxTimeoutInMs: 36e5,
+  randomize: true
+};
+function createDefaultRetryStrategy() {
+  return new ExponentialBackoffRetry(defaultRetryOptions);
+}
 
 // src/fair-queue/scheduler.ts
 var BaseScheduler = class {
@@ -14396,9 +14572,7 @@ var DRRScheduler = class extends BaseScheduler {
         };
       })
     );
-    const eligibleTenants = tenantData.filter(
-      (t) => !t.isAtCapacity && t.deficit >= 1
-    );
+    const eligibleTenants = tenantData.filter((t) => !t.isAtCapacity && t.deficit >= 1);
     const blockedTenants = tenantData.filter((t) => t.isAtCapacity);
     if (blockedTenants.length > 0) {
       this.logger.debug("DRR: tenants blocked by concurrency", {
@@ -14691,11 +14865,7 @@ var WeightedScheduler = class extends BaseScheduler {
   // FairScheduler Implementation
   // ============================================================================
   async selectQueues(masterQueueShard, consumerId, context2) {
-    const snapshot = await this.#getOrCreateSnapshot(
-      masterQueueShard,
-      consumerId,
-      context2
-    );
+    const snapshot = await this.#getOrCreateSnapshot(masterQueueShard, consumerId, context2);
     if (snapshot.queues.length === 0) {
       return [];
     }
@@ -15046,101 +15216,6 @@ var RoundRobinScheduler = class extends BaseScheduler {
     return [...array.slice(normalizedIndex), ...array.slice(0, normalizedIndex)];
   }
 };
-var ExponentialBackoffRetry = class {
-  maxAttempts;
-  options;
-  constructor(options) {
-    this.options = {
-      maxAttempts: options?.maxAttempts ?? 12,
-      factor: options?.factor ?? 2,
-      minTimeoutInMs: options?.minTimeoutInMs ?? 1e3,
-      maxTimeoutInMs: options?.maxTimeoutInMs ?? 36e5,
-      // 1 hour
-      randomize: options?.randomize ?? true
-    };
-    this.maxAttempts = this.options.maxAttempts ?? 12;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    const delay = v3.calculateNextRetryDelay(this.options, attempt);
-    return delay ?? null;
-  }
-};
-var FixedDelayRetry = class {
-  maxAttempts;
-  delayMs;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.delayMs = options.delayMs;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return this.delayMs;
-  }
-};
-var LinearBackoffRetry = class {
-  maxAttempts;
-  baseDelayMs;
-  maxDelayMs;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.baseDelayMs = options.baseDelayMs;
-    this.maxDelayMs = options.maxDelayMs ?? options.baseDelayMs * options.maxAttempts;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    const delay = this.baseDelayMs * attempt;
-    return Math.min(delay, this.maxDelayMs);
-  }
-};
-var NoRetry = class {
-  maxAttempts = 1;
-  getNextDelay(_attempt, _error) {
-    return null;
-  }
-};
-var ImmediateRetry = class {
-  maxAttempts;
-  constructor(maxAttempts) {
-    this.maxAttempts = maxAttempts;
-  }
-  getNextDelay(attempt, _error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return 0;
-  }
-};
-var CustomRetry = class {
-  maxAttempts;
-  calculateDelay;
-  constructor(options) {
-    this.maxAttempts = options.maxAttempts;
-    this.calculateDelay = options.calculateDelay;
-  }
-  getNextDelay(attempt, error) {
-    if (attempt >= this.maxAttempts) {
-      return null;
-    }
-    return this.calculateDelay(attempt, error);
-  }
-};
-var defaultRetryOptions = {
-  maxAttempts: 12,
-  factor: 2,
-  minTimeoutInMs: 1e3,
-  maxTimeoutInMs: 36e5,
-  randomize: true
-};
-function createDefaultRetryStrategy() {
-  return new ExponentialBackoffRetry(defaultRetryOptions);
-}
 
 // src/fair-queue/index.ts
 var FairQueue = class {
@@ -16068,10 +16143,7 @@ var FairQueue = class {
     if (this.concurrencyManager && storedMessage) {
       await this.concurrencyManager.release(descriptor, messageId);
     }
-    const { queueEmpty } = await this.#updateAllIndexesAfterDequeue(
-      queueId,
-      descriptor.tenantId
-    );
+    const { queueEmpty } = await this.#updateAllIndexesAfterDequeue(queueId, descriptor.tenantId);
     if (queueEmpty) {
       this.queueDescriptorCache.delete(queueId);
       this.queueCooloffStates.delete(queueId);
@@ -16328,38 +16400,6 @@ var FairQueue = class {
     }
     return false;
   }
-  #incrementCooloff(queueId) {
-    if (this.queueCooloffStates.size >= this.maxCooloffStatesSize) {
-      this.logger.warn("Cooloff states cache hit size cap, clearing all entries", {
-        size: this.queueCooloffStates.size,
-        cap: this.maxCooloffStatesSize
-      });
-      this.queueCooloffStates.clear();
-    }
-    const state = this.queueCooloffStates.get(queueId) ?? {
-      tag: "normal",
-      consecutiveFailures: 0
-    };
-    if (state.tag === "normal") {
-      const newFailures = state.consecutiveFailures + 1;
-      if (newFailures >= this.cooloffThreshold) {
-        this.queueCooloffStates.set(queueId, {
-          tag: "cooloff",
-          expiresAt: Date.now() + this.cooloffPeriodMs
-        });
-        this.logger.debug("Queue entered cooloff", {
-          queueId,
-          cooloffPeriodMs: this.cooloffPeriodMs,
-          consecutiveFailures: newFailures
-        });
-      } else {
-        this.queueCooloffStates.set(queueId, {
-          tag: "normal",
-          consecutiveFailures: newFailures
-        });
-      }
-    }
-  }
   #resetCooloff(queueId) {
     this.queueCooloffStates.delete(queueId);
   }
@@ -16627,7 +16667,10 @@ var stringToError = zod.z.string().transform((v, ctx) => {
   try {
     return BufferEntryError.parse(JSON.parse(v));
   } catch {
-    ctx.addIssue({ code: zod.z.ZodIssueCode.custom, message: "expected JSON-encoded BufferEntryError" });
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "expected JSON-encoded BufferEntryError"
+    });
     return zod.z.NEVER;
   }
 });
@@ -16825,11 +16868,7 @@ var MollifierBuffer = class {
   // not an error.
   async listEntriesForEnv(envId, maxCount) {
     if (maxCount <= 0) return [];
-    const runIds = await this.redis.lrange(
-      `mollifier:queue:${envId}`,
-      0,
-      maxCount - 1
-    );
+    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) {
@@ -16966,10 +17005,7 @@ var MollifierBuffer = class {
   // never wiped by a slow predecessor.
   async releaseClaim(input) {
     const claimKey = makeIdempotencyClaimKey(input);
-    await this.redis.releaseMollifierClaim(
-      claimKey,
-      `${PENDING_PREFIX}${input.token}`
-    );
+    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.
@@ -17654,9 +17690,7 @@ var MollifierDrainer = class {
     const orgs = await this.buffer.listOrgs();
     if (orgs.length === 0) return { drained: 0, failed: 0 };
     const orgSlice = this.takeOrgSlice(orgs);
-    const envsByOrg = await Promise.all(
-      orgSlice.map((orgId) => this.buffer.listEnvsForOrg(orgId))
-    );
+    const envsByOrg = await Promise.all(orgSlice.map((orgId) => this.buffer.listEnvsForOrg(orgId)));
     const targets = [];
     for (let i = 0; i < orgSlice.length; i++) {
       const orgId = orgSlice[i];
@@ -17869,14 +17903,11 @@ var MollifierDrainer = class {
         } 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
-              }
-            );
+            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", {