@supergrowthai/tq 1.0.1-canary.03bf985

package/dist/index.js

@@ -0,0 +1,1734 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const mongodb = require("mongodb");
+const mq = require("@supergrowthai/mq");
+const crypto = require("crypto");
+const moment = require("moment");
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+class Logger {
+  constructor(prefix, initialLogLevel = 1) {
+    this.prefix = prefix;
+    this.logLevel = initialLogLevel;
+  }
+  getLogLevel() {
+    return this.logLevel;
+  }
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  debug(message, ...args) {
+    if (this.logLevel === 0) {
+      console.debug(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.logLevel <= 1) {
+      console.info(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    console.error(`[${this.prefix}] ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (this.logLevel <= 2) {
+      console.warn(`[${this.prefix}] ${message}`, ...args);
+    }
+  }
+  time(message) {
+    if (this.logLevel < 1) {
+      console.time(`[${this.prefix}] ${message}`);
+    }
+  }
+  timeEnd(message) {
+    if (this.logLevel < 1) {
+      console.timeEnd(`[${this.prefix}] ${message}`);
+    }
+  }
+}
+class LockManager {
+  constructor(cacheProvider, options) {
+    this.cacheProvider = cacheProvider;
+    this.acquireLocks = /* @__PURE__ */ new Map();
+    this.logger = new Logger("MetricsCollector", LogLevel.INFO);
+    this.cacheProvider = cacheProvider;
+    this.prefix = options?.prefix || "lock:";
+    this.defaultTimeout = options?.defaultTimeout || 30 * 60;
+    if (options?.debugLogs)
+      this.logger.setLogLevel(LogLevel.INFO);
+  }
+  /**
+   * Check if a resource is locked
+   */
+  async isLocked(resourceId) {
+    this.logger.debug("isLocked" + resourceId);
+    const exists = await this.cacheProvider.get(this.getKey(resourceId));
+    return !!exists;
+  }
+  /**
+   * Filter out locked resources from an array
+   */
+  async filterLocked(resources, getResourceId) {
+    if (!resources.length) return [];
+    const lockChecks = resources.map((resource) => this.isLocked(getResourceId(resource)));
+    const lockResults = await Promise.all(lockChecks);
+    return resources.filter((_, index) => !lockResults[index]);
+  }
+  /**
+   * Acquire a lock
+   * @returns true if lock was acquired, false if already locked
+   */
+  async acquire(resourceId, timeout = this.defaultTimeout) {
+    this.logger.debug("Acquire" + resourceId);
+    const existingLock = this.acquireLocks.get(resourceId);
+    if (existingLock) {
+      await existingLock;
+      return false;
+    }
+    const lockPromise = this.acquireInternal(resourceId, timeout);
+    this.acquireLocks.set(resourceId, lockPromise);
+    try {
+      return await lockPromise;
+    } finally {
+      this.acquireLocks.delete(resourceId);
+    }
+  }
+  /**
+   * Release a lock
+   */
+  async release(resourceId) {
+    this.logger.debug("Release" + resourceId);
+    const key = this.getKey(resourceId);
+    await this.cacheProvider.del(key);
+  }
+  async acquireInternal(resourceId, timeout) {
+    if (await this.isLocked(resourceId)) return false;
+    const key = this.getKey(resourceId);
+    const result = await this.cacheProvider.set(key, "1", timeout);
+    return result === "OK" || result === "1" || result === 1;
+  }
+  getKey(resourceId) {
+    return `${this.prefix}${resourceId}`;
+  }
+}
+const logger$3 = new Logger("MongoDbAdapter", LogLevel.INFO);
+const TWO_DAYS_MS = 2 * 24 * 60 * 60 * 1e3;
+class MongoDbAdapter {
+  constructor(uri = process.env.MONGODB_URI || "mongodb://localhost:27017", dbName = process.env.DB_NAME || "taskqueue", collectionName = "scheduled") {
+    this.client = null;
+    this.db = null;
+    this.tasksCollection = null;
+    this.uri = uri;
+    this.dbName = dbName;
+    this.collectionName = collectionName;
+  }
+  async initialize() {
+    if (this.db) return;
+    this.client = new mongodb.MongoClient(this.uri);
+    await this.client.connect();
+    this.db = this.client.db(this.dbName);
+    this.tasksCollection = this.db.collection(this.collectionName);
+    await this.tasksCollection.createIndex({ execute_at: 1, status: 1 });
+    await this.tasksCollection.createIndex({ status: 1, processing_started_at: 1 });
+    await this.tasksCollection.createIndex({ expires_at: 1 }, { sparse: true });
+    logger$3.info(`Connected to MongoDB at ${this.uri}/${this.dbName}`);
+  }
+  async addTasksToScheduled(tasks) {
+    if (!tasks.length) return [];
+    const collection = await this.ensureConnection();
+    const transformedTasks = tasks.map((task) => ({
+      _id: task._id,
+      type: task.type,
+      payload: task.payload,
+      execute_at: task.execute_at,
+      status: task.status || "scheduled",
+      retries: task.retries || 0,
+      created_at: task.created_at || /* @__PURE__ */ new Date(),
+      updated_at: /* @__PURE__ */ new Date(),
+      queue_id: task.queue_id,
+      processing_started_at: task.processing_started_at || /* @__PURE__ */ new Date(),
+      expires_at: task.expires_at,
+      task_group: task.task_group,
+      task_hash: task.task_hash,
+      retry_after: task.retry_after,
+      execution_stats: task.execution_stats,
+      force_store: task.force_store
+    }));
+    try {
+      await collection.insertMany(transformedTasks, { ordered: false });
+      return transformedTasks;
+    } catch (error) {
+      if (error.writeErrors) {
+        const successfulTasks = transformedTasks.filter(
+          (_, index) => !error.writeErrors.some((e) => e.index === index)
+        );
+        return successfulTasks;
+      }
+      throw error;
+    }
+  }
+  async getMatureTasks(timestamp) {
+    const collection = await this.ensureConnection();
+    const staleTimestamp = Date.now() - TWO_DAYS_MS;
+    await collection.updateMany(
+      {
+        status: "processing",
+        processing_started_at: { $lt: new Date(staleTimestamp) }
+      },
+      {
+        $set: { status: "scheduled" },
+        $inc: { retries: 1 }
+      }
+    );
+    const filter = {
+      status: "scheduled",
+      execute_at: { $lte: new Date(timestamp) }
+    };
+    const tasks = await collection.find(filter).limit(1e3).toArray();
+    if (tasks.length > 0) {
+      const taskIds = tasks.map((t) => t._id);
+      await collection.updateMany(
+        { _id: { $in: taskIds } },
+        {
+          $set: {
+            status: "processing",
+            processing_started_at: /* @__PURE__ */ new Date()
+          }
+        }
+      );
+    }
+    return tasks;
+  }
+  async markTasksAsProcessing(taskIds, processingStartedAt) {
+    const collection = await this.ensureConnection();
+    await collection.updateMany(
+      { _id: { $in: taskIds } },
+      {
+        $set: {
+          status: "processing",
+          processing_started_at: processingStartedAt,
+          updated_at: /* @__PURE__ */ new Date()
+        }
+      }
+    );
+  }
+  async markTasksAsExecuted(taskIds) {
+    const collection = await this.ensureConnection();
+    await collection.updateMany(
+      { _id: { $in: taskIds } },
+      {
+        $set: {
+          status: "executed",
+          updated_at: /* @__PURE__ */ new Date()
+        }
+      }
+    );
+  }
+  async markTasksAsFailed(taskIds) {
+    const collection = await this.ensureConnection();
+    await collection.updateMany(
+      { _id: { $in: taskIds } },
+      {
+        $set: {
+          status: "failed",
+          updated_at: /* @__PURE__ */ new Date()
+        },
+        $inc: { retries: 1 }
+      }
+    );
+  }
+  async getTasksByIds(taskIds) {
+    const collection = await this.ensureConnection();
+    return collection.find({ _id: { $in: taskIds } }).toArray();
+  }
+  async updateTasks(updates) {
+    const collection = await this.ensureConnection();
+    const bulkOps = updates.map(({ id, updates: updates2 }) => ({
+      updateOne: {
+        filter: { _id: id },
+        update: {
+          $set: {
+            ...updates2,
+            updated_at: /* @__PURE__ */ new Date()
+          }
+        }
+      }
+    }));
+    if (bulkOps.length > 0) {
+      await collection.bulkWrite(bulkOps);
+    }
+  }
+  async getCleanupStats() {
+    const collection = await this.ensureConnection();
+    const orphanedBefore = new Date(Date.now() - TWO_DAYS_MS);
+    const orphanedTasks = await collection.countDocuments({
+      status: "processing",
+      processing_started_at: { $lt: orphanedBefore }
+    });
+    const expiredTasks = await collection.countDocuments({
+      expires_at: { $lt: /* @__PURE__ */ new Date() }
+    });
+    return { orphanedTasks, expiredTasks };
+  }
+  async cleanupTasks(orphanedBefore, expiredBefore) {
+    const collection = await this.ensureConnection();
+    await collection.deleteMany({
+      status: "processing",
+      processing_started_at: { $lt: orphanedBefore }
+    });
+    await collection.deleteMany({
+      expires_at: { $lt: expiredBefore }
+    });
+  }
+  async close() {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.db = null;
+      this.tasksCollection = null;
+      logger$3.info("Disconnected from MongoDB");
+    }
+  }
+  async ensureConnection() {
+    if (!this.tasksCollection) {
+      await this.initialize();
+    }
+    return this.tasksCollection;
+  }
+  generateId() {
+    return new mongodb.ObjectId();
+  }
+}
+class InMemoryAdapter {
+  constructor() {
+    this.scheduledTasks = /* @__PURE__ */ new Map();
+  }
+  async addTasksToScheduled(tasks) {
+    const addedTasks = tasks.map((task) => {
+      const id = task._id;
+      const taskWithId = { ...task };
+      this.scheduledTasks.set(id, taskWithId);
+      return taskWithId;
+    });
+    return addedTasks;
+  }
+  async getMatureTasks(timestamp) {
+    const matureTasks = [];
+    for (const [id, task] of Array.from(this.scheduledTasks.entries())) {
+      if (task.execute_at.getTime() <= timestamp && task.status !== "processing" && task.status !== "executed") {
+        matureTasks.push(task);
+      }
+    }
+    return matureTasks;
+  }
+  async markTasksAsProcessing(taskIds, processingStartedAt) {
+    for (const id of taskIds) {
+      const task = this.scheduledTasks.get(id);
+      if (task) {
+        task.status = "processing";
+        task.processing_started_at = processingStartedAt;
+        this.scheduledTasks.set(id, task);
+      }
+    }
+  }
+  async markTasksAsExecuted(taskIds) {
+    for (const id of taskIds) {
+      const task = this.scheduledTasks.get(id);
+      if (task) {
+        task.status = "executed";
+        task.execute_at = /* @__PURE__ */ new Date();
+        this.scheduledTasks.set(id, task);
+      }
+    }
+  }
+  async markTasksAsFailed(taskIds) {
+    for (const id of taskIds) {
+      const task = this.scheduledTasks.get(id);
+      if (task) {
+        task.status = "failed";
+        task.execution_stats = { ...task.execution_stats, failed_at: /* @__PURE__ */ new Date() };
+        this.scheduledTasks.set(id, task);
+      }
+    }
+  }
+  async getTasksByIds(taskIds) {
+    return taskIds.map((id) => this.scheduledTasks.get(id)).filter(Boolean);
+  }
+  async updateTasks(updates) {
+    for (const { id, updates: taskUpdates } of updates) {
+      const task = this.scheduledTasks.get(id);
+      if (task) {
+        Object.assign(task, taskUpdates);
+        this.scheduledTasks.set(id, task);
+      }
+    }
+  }
+  async getCleanupStats() {
+    let orphanedTasks = 0;
+    let expiredTasks = 0;
+    const now = Date.now();
+    for (const task of Array.from(this.scheduledTasks.values())) {
+      if (task.status === "processing" && task.processing_started_at && now - task.processing_started_at.getTime() > 3e5) {
+        orphanedTasks++;
+      }
+      if (task.expires_at && now > task.expires_at.getTime()) {
+        expiredTasks++;
+      }
+    }
+    return { orphanedTasks, expiredTasks };
+  }
+  async cleanupTasks(orphanedBefore, expiredBefore) {
+    for (const [id, task] of Array.from(this.scheduledTasks.entries())) {
+      const shouldDelete = task.status === "processing" && task.processing_started_at && task.processing_started_at < orphanedBefore || task.expires_at && task.expires_at < expiredBefore;
+      if (shouldDelete) {
+        this.scheduledTasks.delete(id);
+      }
+    }
+  }
+  async initialize() {
+  }
+  async close() {
+    this.scheduledTasks.clear();
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+}
+class TaskStore {
+  constructor(databaseAdapter) {
+    this.databaseAdapter = databaseAdapter;
+  }
+  /**
+   * Adds multiple tasks to the scheduled queue
+   */
+  async addTasksToScheduled(tasks) {
+    if (!tasks.length) return [];
+    const transformedTasks = tasks.map((task) => ({
+      _id: task._id,
+      type: task.type,
+      queue_id: mq.getEnvironmentQueueName(task.queue_id),
+      payload: task.payload,
+      execute_at: task.execute_at,
+      expires_at: task.expires_at,
+      status: "scheduled",
+      task_group: task.task_group,
+      task_hash: task.task_hash,
+      retries: task.retries || 0,
+      retry_after: task.retry_after,
+      execution_stats: task.execution_stats,
+      created_at: task.created_at || /* @__PURE__ */ new Date(),
+      updated_at: task.updated_at || /* @__PURE__ */ new Date(),
+      processing_started_at: task.processing_started_at || /* @__PURE__ */ new Date(),
+      force_store: task.force_store
+    }));
+    return await this.databaseAdapter.addTasksToScheduled(transformedTasks);
+  }
+  /**
+   * Gets mature tasks that are ready to be processed
+   * Implements a two-phase approach:
+   * 1. Reset stale processing tasks
+   * 2. Fetch and mark new mature tasks
+   */
+  async getMatureTasks(timestamp) {
+    return await this.databaseAdapter.getMatureTasks(timestamp);
+  }
+  /**
+   * Marks tasks as processing with current timestamp
+   */
+  async markTasksAsProcessing(taskIds) {
+    await this.databaseAdapter.markTasksAsProcessing(taskIds, /* @__PURE__ */ new Date());
+  }
+  /**
+   * Marks tasks as executed/completed
+   */
+  async markTasksAsExecuted(taskIds) {
+    await this.databaseAdapter.markTasksAsExecuted(taskIds);
+  }
+  /**
+   * Marks tasks as failed and increments retry count
+   */
+  async markTasksAsFailed(taskIds) {
+    await this.databaseAdapter.markTasksAsFailed(taskIds);
+  }
+  /**
+   * Updates multiple tasks with specific updates
+   */
+  async updateTasks(updates) {
+    await this.databaseAdapter.updateTasks(updates);
+  }
+  /**
+   * Gets tasks by their IDs
+   */
+  async getTasksByIds(taskIds) {
+    return await this.databaseAdapter.getTasksByIds(taskIds);
+  }
+  /**
+   * Gets cleanup statistics
+   */
+  async getCleanupStats() {
+    return await this.databaseAdapter.getCleanupStats();
+  }
+  /**
+   * Cleans up orphaned and expired tasks
+   */
+  async cleanupTasks() {
+    const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1e3);
+    const now = /* @__PURE__ */ new Date();
+    await this.databaseAdapter.cleanupTasks(twoDaysAgo, now);
+  }
+  /**
+   * Updates tasks for retry with new execution time and retry count
+   */
+  async updateTasksForRetry(tasks) {
+    const updates = tasks.map((task) => ({
+      id: task._id,
+      updates: {
+        execute_at: task.execute_at,
+        status: task.status,
+        execution_stats: task.execution_stats,
+        updated_at: /* @__PURE__ */ new Date()
+      }
+    }));
+    await this.databaseAdapter.updateTasks(updates);
+  }
+  /**
+   * Marks tasks as successful/completed
+   */
+  async markTasksAsSuccess(tasks) {
+    const taskIds = tasks.map((task) => task._id);
+    await this.databaseAdapter.markTasksAsExecuted(taskIds);
+  }
+  /**
+   * Marks tasks as ignored (same as failed for now)
+   */
+  async markTasksAsIgnored(tasks) {
+    const taskIds = tasks.map((task) => task._id);
+    await this.databaseAdapter.markTasksAsFailed(taskIds);
+  }
+}
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var _baseSlice;
+var hasRequired_baseSlice;
+function require_baseSlice() {
+  if (hasRequired_baseSlice) return _baseSlice;
+  hasRequired_baseSlice = 1;
+  function baseSlice(array, start, end) {
+    var index = -1, length = array.length;
+    if (start < 0) {
+      start = -start > length ? 0 : length + start;
+    }
+    end = end > length ? length : end;
+    if (end < 0) {
+      end += length;
+    }
+    length = start > end ? 0 : end - start >>> 0;
+    start >>>= 0;
+    var result = Array(length);
+    while (++index < length) {
+      result[index] = array[index + start];
+    }
+    return result;
+  }
+  _baseSlice = baseSlice;
+  return _baseSlice;
+}
+var eq_1;
+var hasRequiredEq;
+function requireEq() {
+  if (hasRequiredEq) return eq_1;
+  hasRequiredEq = 1;
+  function eq(value, other) {
+    return value === other || value !== value && other !== other;
+  }
+  eq_1 = eq;
+  return eq_1;
+}
+var _freeGlobal;
+var hasRequired_freeGlobal;
+function require_freeGlobal() {
+  if (hasRequired_freeGlobal) return _freeGlobal;
+  hasRequired_freeGlobal = 1;
+  var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+  _freeGlobal = freeGlobal;
+  return _freeGlobal;
+}
+var _root;
+var hasRequired_root;
+function require_root() {
+  if (hasRequired_root) return _root;
+  hasRequired_root = 1;
+  var freeGlobal = require_freeGlobal();
+  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+  var root = freeGlobal || freeSelf || Function("return this")();
+  _root = root;
+  return _root;
+}
+var _Symbol;
+var hasRequired_Symbol;
+function require_Symbol() {
+  if (hasRequired_Symbol) return _Symbol;
+  hasRequired_Symbol = 1;
+  var root = require_root();
+  var Symbol2 = root.Symbol;
+  _Symbol = Symbol2;
+  return _Symbol;
+}
+var _getRawTag;
+var hasRequired_getRawTag;
+function require_getRawTag() {
+  if (hasRequired_getRawTag) return _getRawTag;
+  hasRequired_getRawTag = 1;
+  var Symbol2 = require_Symbol();
+  var objectProto = Object.prototype;
+  var hasOwnProperty = objectProto.hasOwnProperty;
+  var nativeObjectToString = objectProto.toString;
+  var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+    try {
+      value[symToStringTag] = void 0;
+      var unmasked = true;
+    } catch (e) {
+    }
+    var result = nativeObjectToString.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag] = tag;
+      } else {
+        delete value[symToStringTag];
+      }
+    }
+    return result;
+  }
+  _getRawTag = getRawTag;
+  return _getRawTag;
+}
+var _objectToString;
+var hasRequired_objectToString;
+function require_objectToString() {
+  if (hasRequired_objectToString) return _objectToString;
+  hasRequired_objectToString = 1;
+  var objectProto = Object.prototype;
+  var nativeObjectToString = objectProto.toString;
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+  _objectToString = objectToString;
+  return _objectToString;
+}
+var _baseGetTag;
+var hasRequired_baseGetTag;
+function require_baseGetTag() {
+  if (hasRequired_baseGetTag) return _baseGetTag;
+  hasRequired_baseGetTag = 1;
+  var Symbol2 = require_Symbol(), getRawTag = require_getRawTag(), objectToString = require_objectToString();
+  var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+  var symToStringTag = Symbol2 ? Symbol2.toStringTag : void 0;
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === void 0 ? undefinedTag : nullTag;
+    }
+    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+  }
+  _baseGetTag = baseGetTag;
+  return _baseGetTag;
+}
+var isObject_1;
+var hasRequiredIsObject;
+function requireIsObject() {
+  if (hasRequiredIsObject) return isObject_1;
+  hasRequiredIsObject = 1;
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == "object" || type == "function");
+  }
+  isObject_1 = isObject;
+  return isObject_1;
+}
+var isFunction_1;
+var hasRequiredIsFunction;
+function requireIsFunction() {
+  if (hasRequiredIsFunction) return isFunction_1;
+  hasRequiredIsFunction = 1;
+  var baseGetTag = require_baseGetTag(), isObject = requireIsObject();
+  var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+  function isFunction(value) {
+    if (!isObject(value)) {
+      return false;
+    }
+    var tag = baseGetTag(value);
+    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+  }
+  isFunction_1 = isFunction;
+  return isFunction_1;
+}
+var isLength_1;
+var hasRequiredIsLength;
+function requireIsLength() {
+  if (hasRequiredIsLength) return isLength_1;
+  hasRequiredIsLength = 1;
+  var MAX_SAFE_INTEGER = 9007199254740991;
+  function isLength(value) {
+    return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  }
+  isLength_1 = isLength;
+  return isLength_1;
+}
+var isArrayLike_1;
+var hasRequiredIsArrayLike;
+function requireIsArrayLike() {
+  if (hasRequiredIsArrayLike) return isArrayLike_1;
+  hasRequiredIsArrayLike = 1;
+  var isFunction = requireIsFunction(), isLength = requireIsLength();
+  function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(value);
+  }
+  isArrayLike_1 = isArrayLike;
+  return isArrayLike_1;
+}
+var _isIndex;
+var hasRequired_isIndex;
+function require_isIndex() {
+  if (hasRequired_isIndex) return _isIndex;
+  hasRequired_isIndex = 1;
+  var MAX_SAFE_INTEGER = 9007199254740991;
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+  function isIndex(value, length) {
+    var type = typeof value;
+    length = length == null ? MAX_SAFE_INTEGER : length;
+    return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+  }
+  _isIndex = isIndex;
+  return _isIndex;
+}
+var _isIterateeCall;
+var hasRequired_isIterateeCall;
+function require_isIterateeCall() {
+  if (hasRequired_isIterateeCall) return _isIterateeCall;
+  hasRequired_isIterateeCall = 1;
+  var eq = requireEq(), isArrayLike = requireIsArrayLike(), isIndex = require_isIndex(), isObject = requireIsObject();
+  function isIterateeCall(value, index, object) {
+    if (!isObject(object)) {
+      return false;
+    }
+    var type = typeof index;
+    if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
+      return eq(object[index], value);
+    }
+    return false;
+  }
+  _isIterateeCall = isIterateeCall;
+  return _isIterateeCall;
+}
+var _trimmedEndIndex;
+var hasRequired_trimmedEndIndex;
+function require_trimmedEndIndex() {
+  if (hasRequired_trimmedEndIndex) return _trimmedEndIndex;
+  hasRequired_trimmedEndIndex = 1;
+  var reWhitespace = /\s/;
+  function trimmedEndIndex(string) {
+    var index = string.length;
+    while (index-- && reWhitespace.test(string.charAt(index))) {
+    }
+    return index;
+  }
+  _trimmedEndIndex = trimmedEndIndex;
+  return _trimmedEndIndex;
+}
+var _baseTrim;
+var hasRequired_baseTrim;
+function require_baseTrim() {
+  if (hasRequired_baseTrim) return _baseTrim;
+  hasRequired_baseTrim = 1;
+  var trimmedEndIndex = require_trimmedEndIndex();
+  var reTrimStart = /^\s+/;
+  function baseTrim(string) {
+    return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+  }
+  _baseTrim = baseTrim;
+  return _baseTrim;
+}
+var isObjectLike_1;
+var hasRequiredIsObjectLike;
+function requireIsObjectLike() {
+  if (hasRequiredIsObjectLike) return isObjectLike_1;
+  hasRequiredIsObjectLike = 1;
+  function isObjectLike(value) {
+    return value != null && typeof value == "object";
+  }
+  isObjectLike_1 = isObjectLike;
+  return isObjectLike_1;
+}
+var isSymbol_1;
+var hasRequiredIsSymbol;
+function requireIsSymbol() {
+  if (hasRequiredIsSymbol) return isSymbol_1;
+  hasRequiredIsSymbol = 1;
+  var baseGetTag = require_baseGetTag(), isObjectLike = requireIsObjectLike();
+  var symbolTag = "[object Symbol]";
+  function isSymbol(value) {
+    return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+  }
+  isSymbol_1 = isSymbol;
+  return isSymbol_1;
+}
+var toNumber_1;
+var hasRequiredToNumber;
+function requireToNumber() {
+  if (hasRequiredToNumber) return toNumber_1;
+  hasRequiredToNumber = 1;
+  var baseTrim = require_baseTrim(), isObject = requireIsObject(), isSymbol = requireIsSymbol();
+  var NAN = 0 / 0;
+  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+  var reIsBinary = /^0b[01]+$/i;
+  var reIsOctal = /^0o[0-7]+$/i;
+  var freeParseInt = parseInt;
+  function toNumber(value) {
+    if (typeof value == "number") {
+      return value;
+    }
+    if (isSymbol(value)) {
+      return NAN;
+    }
+    if (isObject(value)) {
+      var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+      value = isObject(other) ? other + "" : other;
+    }
+    if (typeof value != "string") {
+      return value === 0 ? value : +value;
+    }
+    value = baseTrim(value);
+    var isBinary = reIsBinary.test(value);
+    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+  }
+  toNumber_1 = toNumber;
+  return toNumber_1;
+}
+var toFinite_1;
+var hasRequiredToFinite;
+function requireToFinite() {
+  if (hasRequiredToFinite) return toFinite_1;
+  hasRequiredToFinite = 1;
+  var toNumber = requireToNumber();
+  var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+  function toFinite(value) {
+    if (!value) {
+      return value === 0 ? value : 0;
+    }
+    value = toNumber(value);
+    if (value === INFINITY || value === -INFINITY) {
+      var sign = value < 0 ? -1 : 1;
+      return sign * MAX_INTEGER;
+    }
+    return value === value ? value : 0;
+  }
+  toFinite_1 = toFinite;
+  return toFinite_1;
+}
+var toInteger_1;
+var hasRequiredToInteger;
+function requireToInteger() {
+  if (hasRequiredToInteger) return toInteger_1;
+  hasRequiredToInteger = 1;
+  var toFinite = requireToFinite();
+  function toInteger(value) {
+    var result = toFinite(value), remainder = result % 1;
+    return result === result ? remainder ? result - remainder : result : 0;
+  }
+  toInteger_1 = toInteger;
+  return toInteger_1;
+}
+var chunk_1;
+var hasRequiredChunk;
+function requireChunk() {
+  if (hasRequiredChunk) return chunk_1;
+  hasRequiredChunk = 1;
+  var baseSlice = require_baseSlice(), isIterateeCall = require_isIterateeCall(), toInteger = requireToInteger();
+  var nativeCeil = Math.ceil, nativeMax = Math.max;
+  function chunk2(array, size, guard) {
+    if (guard ? isIterateeCall(array, size, guard) : size === void 0) {
+      size = 1;
+    } else {
+      size = nativeMax(toInteger(size), 0);
+    }
+    var length = array == null ? 0 : array.length;
+    if (!length || size < 1) {
+      return [];
+    }
+    var index = 0, resIndex = 0, result = Array(nativeCeil(length / size));
+    while (index < length) {
+      result[resIndex++] = baseSlice(array, index, index += size);
+    }
+    return result;
+  }
+  chunk_1 = chunk2;
+  return chunk_1;
+}
+var chunkExports = requireChunk();
+const chunk = /* @__PURE__ */ getDefaultExportFromCjs(chunkExports);
+let taskIdCacheKeyGen = null;
+function tId(task) {
+  if (task._id) return task._id.toString();
+  if (task.task_hash) return task.task_hash;
+  if (!taskIdCacheKeyGen) {
+    const hash = crypto.createHash("sha256");
+    hash.update(JSON.stringify({
+      type: task.type,
+      queue_id: task.queue_id,
+      created_at: task.created_at,
+      payload: task.payload
+    }));
+    return `task-id-gen:${hash.digest("hex")}`;
+  }
+  return taskIdCacheKeyGen.for(task.type, task.queue_id, task.created_at, task.payload);
+}
+function setKeyGenerator(generator) {
+  taskIdCacheKeyGen = generator;
+}
+const logger$2 = new Logger("Actions", LogLevel.INFO);
+class Actions {
+  constructor(taskRunnerId) {
+    this.taskContexts = /* @__PURE__ */ new Map();
+    this.taskRunnerId = taskRunnerId;
+  }
+  /**
+   * Fork execution context for a specific task (for single-task executors)
+   */
+  forkForTask(task) {
+    const taskId = tId(task);
+    const context = { task, actions: [] };
+    this.taskContexts.set(taskId, context);
+    return {
+      fail: (t) => {
+        context.actions.push({
+          type: "fail",
+          timestamp: Date.now(),
+          task: t
+        });
+        logger$2.error(`[${this.taskRunnerId}] Task failed: ${tId(t)} (${t.type})`);
+      },
+      success: (t) => {
+        context.actions.push({
+          type: "success",
+          timestamp: Date.now(),
+          task: t
+        });
+        logger$2.info(`[${this.taskRunnerId}] Task succeeded: ${tId(t)} (${t.type})`);
+      },
+      addTasks: (tasks) => {
+        context.actions.push({
+          type: "addTasks",
+          timestamp: Date.now(),
+          newTasks: tasks
+        });
+        logger$2.info(`[${this.taskRunnerId}] Task ${taskId} adding ${tasks.length} new tasks`);
+      }
+    };
+  }
+  // For multi-task executors - they use the root Actions directly (no forking)
+  fail(task) {
+    const taskId = tId(task);
+    let context = this.taskContexts.get(taskId);
+    if (!context) {
+      context = { task, actions: [] };
+      this.taskContexts.set(taskId, context);
+    }
+    context.actions.push({
+      type: "fail",
+      timestamp: Date.now(),
+      task
+    });
+    logger$2.error(`[${this.taskRunnerId}] Task failed: ${taskId} (${task.type})`);
+  }
+  success(task) {
+    const taskId = tId(task);
+    let context = this.taskContexts.get(taskId);
+    if (!context) {
+      context = { task, actions: [] };
+      this.taskContexts.set(taskId, context);
+    }
+    context.actions.push({
+      type: "success",
+      timestamp: Date.now(),
+      task
+    });
+    logger$2.info(`[${this.taskRunnerId}] Task succeeded: ${taskId} (${task.type})`);
+  }
+  addTasks(tasks) {
+    logger$2.info(`[${this.taskRunnerId}] Adding ${tasks.length} new tasks`);
+    const batchKey = `__batch_${this.taskRunnerId}__`;
+    let batchContext = this.taskContexts.get(batchKey);
+    if (!batchContext) {
+      batchContext = { task: null, actions: [] };
+      this.taskContexts.set(batchKey, batchContext);
+    }
+    batchContext.actions.push({
+      type: "addTasks",
+      timestamp: Date.now(),
+      newTasks: tasks
+    });
+  }
+  addIgnoredTask(task) {
+    const taskId = tId(task);
+    this.taskContexts.set(taskId, { task, actions: [] });
+    logger$2.warn(`[${this.taskRunnerId}] Task ignored: ${taskId} (${task.type})`);
+  }
+  /**
+   * Extract actions for a single task (used by async tasks)
+   */
+  extractTaskActions(taskId) {
+    const results = {
+      failedTasks: [],
+      successTasks: [],
+      newTasks: [],
+      ignoredTasks: []
+    };
+    const context = this.taskContexts.get(taskId);
+    if (!context) return results;
+    if (context.actions.length === 0 && context.task) {
+      results.ignoredTasks.push(context.task);
+    } else {
+      for (const action of context.actions) {
+        if (action.type === "success" && action.task) {
+          results.successTasks.push(action.task);
+          const targetTaskId = tId(action.task);
+          if (targetTaskId !== taskId) {
+            this.taskContexts.delete(targetTaskId);
+          }
+        } else if (action.type === "fail" && action.task) {
+          results.failedTasks.push(action.task);
+          const targetTaskId = tId(action.task);
+          if (targetTaskId !== taskId) {
+            this.taskContexts.delete(targetTaskId);
+          }
+        } else if (action.type === "addTasks" && action.newTasks) {
+          results.newTasks.push(...action.newTasks);
+        }
+      }
+    }
+    this.taskContexts.delete(taskId);
+    return results;
+  }
+  /**
+   * Extract sync results including batch context (for sync processing)
+   */
+  extractSyncResults(excludeTaskIds) {
+    const results = {
+      failedTasks: [],
+      successTasks: [],
+      newTasks: [],
+      ignoredTasks: []
+    };
+    const excludeSet = new Set(excludeTaskIds);
+    const batchKey = `__batch_${this.taskRunnerId}__`;
+    for (const [taskId, context] of this.taskContexts) {
+      if (excludeSet.has(taskId)) continue;
+      if (taskId === batchKey) {
+        for (const action of context.actions) {
+          if (action.type === "addTasks" && action.newTasks) {
+            results.newTasks.push(...action.newTasks);
+          }
+        }
+      } else {
+        if (context.actions.length === 0 && context.task) {
+          results.ignoredTasks.push(context.task);
+        } else {
+          for (const action of context.actions) {
+            if (action.type === "success" && action.task) {
+              results.successTasks.push(action.task);
+            } else if (action.type === "fail" && action.task) {
+              results.failedTasks.push(action.task);
+            } else if (action.type === "addTasks" && action.newTasks) {
+              results.newTasks.push(...action.newTasks);
+            }
+          }
+        }
+      }
+    }
+    for (const [taskId] of this.taskContexts) {
+      if (!excludeSet.has(taskId)) {
+        this.taskContexts.delete(taskId);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get all results (mainly for backward compatibility)
+   */
+  getResults() {
+    return this.extractSyncResults([]);
+  }
+}
+const logger$1 = new Logger("AsyncActions", LogLevel.INFO);
+class AsyncActions {
+  constructor(messageQueue, taskStore, taskQueue, actions, task, generateId) {
+    this.messageQueue = messageQueue;
+    this.taskStore = taskStore;
+    this.taskQueue = taskQueue;
+    this.generateId = generateId;
+    this.actions = actions;
+    this.taskId = tId(task);
+  }
+  /**
+   * Called when the async promise completes to execute the collected actions
+   */
+  async onPromiseFulfilled() {
+    const results = this.actions.extractTaskActions(this.taskId);
+    const hasCompletion = results.successTasks.length > 0 || results.failedTasks.length > 0;
+    if (!hasCompletion) {
+      throw new Error(`Async task ${this.taskId} completed without calling success() or fail()`);
+    }
+    logger$1.info(`[AsyncActions] Processing results for async task ${this.taskId}: ${results.successTasks.length} success, ${results.failedTasks.length} failed, ${results.newTasks.length} new tasks`);
+    if (results.failedTasks.length > 0) {
+      try {
+        const failedTaskIds = results.failedTasks.map((task) => task._id);
+        await this.taskStore.markTasksAsFailed(failedTaskIds);
+        logger$1.info(`[AsyncActions] Marked ${results.failedTasks.length} tasks as failed in database`);
+      } catch (err) {
+        logger$1.error(`[AsyncActions] Failed to mark tasks as failed:`, err);
+        throw err;
+      }
+    }
+    if (results.successTasks.length > 0) {
+      try {
+        await this.taskStore.markTasksAsSuccess(results.successTasks);
+        logger$1.info(`[AsyncActions] Marked ${results.successTasks.length} tasks as success in database`);
+      } catch (err) {
+        logger$1.error(`[AsyncActions] Failed to mark tasks as success:`, err);
+        throw err;
+      }
+    }
+    if (results.newTasks.length > 0) {
+      logger$1.info(`[AsyncActions] Scheduling ${results.newTasks.length} new tasks`);
+      await this.scheduleNewTasks(results.newTasks);
+    }
+  }
+  /**
+   * Schedule new tasks - replicates the logic from task-handler's addTasks
+   */
+  async scheduleNewTasks(tasks) {
+    const now = /* @__PURE__ */ new Date();
+    const immediate = {};
+    const future = [];
+    for (const task of tasks) {
+      const timeDiff = (task.execute_at.getTime() - now.getTime()) / 1e3 / 60;
+      if (timeDiff > 2) {
+        future.push(task);
+      } else {
+        const queue = task.queue_id;
+        if (!immediate[queue]) {
+          immediate[queue] = [];
+        }
+        immediate[queue].push(task);
+      }
+    }
+    const iQueues = Object.keys(immediate);
+    for (const queue of iQueues) {
+      const queueTasks = immediate[queue].map((task) => {
+        const executor = this.taskQueue.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: this.generateId() } : {};
+        return { ...id, ...task };
+      });
+      try {
+        await this.messageQueue.addMessages(queue, queueTasks);
+        logger$1.info(`[AsyncActions] Added ${queueTasks.length} immediate tasks to queue ${queue}`);
+      } catch (err) {
+        logger$1.error(`[AsyncActions] Failed to add tasks to queue ${queue}:`, err);
+        throw err;
+      }
+    }
+    if (future.length > 0) {
+      const futureTasks = future.map((task) => {
+        const executor = this.taskQueue.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: this.generateId() } : {};
+        return { ...id, ...task };
+      });
+      try {
+        await this.taskStore.addTasksToScheduled(futureTasks);
+        logger$1.info(`[AsyncActions] Added ${futureTasks.length} future tasks to database`);
+      } catch (err) {
+        logger$1.error(`[AsyncActions] Failed to add tasks to database:`, err);
+        throw err;
+      }
+    }
+  }
+}
+class TaskRunner {
+  constructor(messageQueue, taskQueue, taskStore, cacheProvider, generateId) {
+    this.messageQueue = messageQueue;
+    this.taskQueue = taskQueue;
+    this.taskStore = taskStore;
+    this.generateId = generateId;
+    this.logger = new Logger("TaskRunner", LogLevel.INFO);
+    this.lockManager = new LockManager(cacheProvider, {
+      prefix: "task_lock_",
+      defaultTimeout: 30 * 60
+    });
+  }
+  async run(taskRunnerId, tasksRaw, asyncTaskManager) {
+    this.logger.info(`[${taskRunnerId}] Starting task runner`);
+    this.logger.info(`[${taskRunnerId}] Processing ${tasksRaw.length} provided tasks`);
+    const tasks = await this.lockManager.filterLocked(tasksRaw, tId);
+    this.logger.info(`[${taskRunnerId}] Found ${tasks.length} not locked tasks to process`);
+    await Promise.all(tasks.map((t) => this.lockManager.acquire(tId(t))));
+    const groupedTasksObject = tasks.reduce((acc, task) => {
+      acc[task.type] = acc[task.type] || [];
+      acc[task.type].push(task);
+      return acc;
+    }, {});
+    const groupedTasksArray = Object.keys(groupedTasksObject).reduce((acc, type) => {
+      acc.push({ type, tasks: groupedTasksObject[type] });
+      return acc;
+    }, []);
+    this.logger.info(`[${taskRunnerId}] Task groups: ${groupedTasksArray.map((g) => `${g.type}: ${g.tasks.length}`).join(", ")}`);
+    const actions = new Actions(taskRunnerId);
+    const asyncTasks = [];
+    for (let i = 0; i < groupedTasksArray.length; i++) {
+      const taskGroup = groupedTasksArray[i];
+      const firstTask = taskGroup.tasks[0];
+      if (!firstTask) {
+        this.logger.warn(`[${taskRunnerId}] No tasks found for type: ${taskGroup.type}`);
+        continue;
+      }
+      const executor = this.taskQueue.getExecutor(firstTask.queue_id, taskGroup.type);
+      if (!executor) {
+        this.logger.warn(`[${taskRunnerId}] No executor found for type: ${taskGroup.type} in queue ${firstTask.queue_id}`);
+        for (const task of taskGroup.tasks) {
+          const taskWithId = task._id ? task : { ...task, _id: "" };
+          actions.addIgnoredTask(taskWithId);
+        }
+        continue;
+      }
+      if (executor.asyncConfig?.handoffTimeout && asyncTaskManager && !asyncTaskManager.canAcceptTask()) {
+        this.logger.warn(`[${taskRunnerId}] Async queue full, rescheduling ${taskGroup.tasks.length} ${taskGroup.type} tasks for 3 min later`);
+        const rescheduledTasks = taskGroup.tasks.map((task) => ({
+          ...task,
+          execute_at: new Date(Date.now() + 18e4),
+          status: "scheduled"
+        }));
+        await this.taskStore.updateTasksForRetry(rescheduledTasks);
+        continue;
+      }
+      this.logger.info(`[${taskRunnerId}] Processing ${taskGroup.tasks.length} tasks of type: ${taskGroup.type}`);
+      if (executor.multiple) {
+        await executor.onTasks(taskGroup.tasks, actions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTasks failed: ${err}`));
+      } else {
+        if (executor.parallel) {
+          const chunks = chunk(taskGroup.tasks, executor.chunkSize);
+          this.logger.info(`[${taskRunnerId}] Processing in parallel chunks of ${executor.chunkSize}`);
+          for (const chunk2 of chunks) {
+            const chunkTasks = [];
+            for (let j = 0; j < chunk2.length; j++) {
+              const taskActions = actions.forkForTask(chunk2[j]);
+              chunkTasks.push(executor.onTask(chunk2[j], taskActions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`)));
+            }
+            await Promise.all(chunkTasks);
+          }
+        } else {
+          const timeoutMs = executor.asyncConfig?.handoffTimeout;
+          for (let j = 0; j < taskGroup.tasks.length; j++) {
+            const task = taskGroup.tasks[j];
+            if (!timeoutMs) {
+              const taskActions = actions.forkForTask(task);
+              await executor.onTask(task, taskActions).catch((err) => this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`));
+            } else {
+              const startTime = Date.now();
+              const taskActions = actions.forkForTask(task);
+              const taskPromise = executor.onTask(task, taskActions).catch((err) => {
+                this.logger.error(`[${taskRunnerId}] executor.onTask failed: ${err}`);
+              });
+              const timeoutPromise = new Promise(
+                (resolve) => setTimeout(() => {
+                  resolve("~~~timeout");
+                }, timeoutMs)
+              );
+              const result = await Promise.race([taskPromise, timeoutPromise]);
+              if (result === "~~~timeout") {
+                this.logger.info(`[${taskRunnerId}] Task ${tId(task)} (${task.type}) exceeded ${timeoutMs}ms, marking for async handoff`);
+                if (!asyncTaskManager) {
+                  throw new Error(`Task ${task.type} exceeded timeout but AsyncTaskManager not initialized!`);
+                }
+                if (!task._id) {
+                  this.logger.error(`[${taskRunnerId}] Cannot hand off task without _id (type: ${task.type}). Task will continue but won't be tracked.`);
+                } else {
+                  const asyncActions = new AsyncActions(this.messageQueue, this.taskStore, this.taskQueue, actions, task, this.generateId);
+                  const asyncPromise = taskPromise.finally(async () => {
+                    try {
+                      await asyncActions.onPromiseFulfilled();
+                    } catch (err) {
+                      this.logger.error(`[${taskRunnerId}] Failed to execute async actions for task ${tId(task)}:`, err);
+                    }
+                  });
+                  asyncTasks.push({
+                    task,
+                    promise: asyncPromise,
+                    startTime,
+                    actions: asyncActions
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    const asyncTaskIds = asyncTasks.map((at) => tId(at.task));
+    const results = actions.extractSyncResults(asyncTaskIds);
+    this.logger.info(`[${taskRunnerId}] Completing run - Success: ${results.successTasks.length}, Failed: ${results.failedTasks.length}, New: ${results.newTasks.length}, Async: ${asyncTasks.length}, Ignored: ${results.ignoredTasks.length}`);
+    await Promise.all(tasks.map((t) => this.lockManager.release(tId(t))));
+    return { ...results, asyncTasks };
+  }
+}
+function getEnabledQueues() {
+  let enabledQueues = process.env.ENABLED_QUEUES ? JSON.parse(process.env.ENABLED_QUEUES) : [];
+  if (enabledQueues.length === 0) throw new Error("No queues enabled");
+  return enabledQueues.map(mq.getEnvironmentQueueName);
+}
+const METRICS_KEY_PREFIX = "task_metrics:";
+const DISCARDED_TASKS_KEY = `${METRICS_KEY_PREFIX}discarded_tasks`;
+const STATS_THRESHOLD = parseInt(process.env.TQ_STATS_THRESHOLD || "1000");
+const FAILURE_THRESHOLD = parseInt(process.env.TQ_STATS_FAILURE_THRESHOLD || "100");
+const INSTANCE_ID = process.env.INSTANCE_ID || "unknown";
+const slack = { sendSlackMessage: console.log };
+class TaskHandler {
+  constructor(messageQueue, taskQueuesManager, databaseAdapter, cacheAdapter, asyncTaskManager) {
+    this.messageQueue = messageQueue;
+    this.taskQueuesManager = taskQueuesManager;
+    this.databaseAdapter = databaseAdapter;
+    this.cacheAdapter = cacheAdapter;
+    this.asyncTaskManager = asyncTaskManager;
+    this.matureTaskTimer = null;
+    this.queueStats = /* @__PURE__ */ new Map();
+    this.logger = new Logger("TaskHandler", LogLevel.INFO);
+    this.taskStore = new TaskStore(databaseAdapter);
+    this.taskRunner = new TaskRunner(messageQueue, taskQueuesManager, this.taskStore, this.cacheAdapter, databaseAdapter.generateId.bind(databaseAdapter));
+  }
+  async addTasks(tasks) {
+    const diffedItems = tasks.reduce(
+      (acc, { force_store, ...task }) => {
+        const currentTime = /* @__PURE__ */ new Date();
+        const executeTime = task.execute_at;
+        const timeDifference = (executeTime.getTime() - currentTime.getTime()) / 1e3 / 60;
+        const queue = task.queue_id;
+        if (timeDifference > 2 || force_store) {
+          acc.future[queue] = acc.future[queue] || [];
+          acc.future[queue].push(task);
+        } else {
+          acc.immediate[queue] = acc.immediate[queue] || [];
+          acc.immediate[queue].push(task);
+        }
+        return acc;
+      },
+      {
+        future: {},
+        immediate: {}
+      }
+    );
+    const iQueues = Object.keys(diffedItems.immediate);
+    for (let i = 0; i < iQueues.length; i++) {
+      const queue = iQueues[i];
+      const tasks2 = diffedItems.immediate[queue].map((task) => {
+        const executor = this.taskQueuesManager.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: this.databaseAdapter.generateId() } : {};
+        return { ...id, ...task };
+      });
+      await this.messageQueue.addMessages(queue, tasks2);
+    }
+    const fQueues = Object.keys(diffedItems.future);
+    for (let i = 0; i < fQueues.length; i++) {
+      const queue = fQueues[i];
+      const tasks2 = diffedItems.future[queue].map((task) => {
+        const executor = this.taskQueuesManager.getExecutor(task.queue_id, task.type);
+        const shouldStoreOnFailure = executor?.store_on_failure ?? false;
+        const id = shouldStoreOnFailure ? { _id: this.databaseAdapter.generateId() } : {};
+        return { ...id, ...task };
+      });
+      await this.taskStore.addTasksToScheduled(tasks2);
+    }
+  }
+  async postProcessTasks({
+    failedTasks: failedTasksRaw,
+    newTasks,
+    successTasks
+  }) {
+    const tasksToRetry = [];
+    const finalFailedTasks = [];
+    let discardedTasksCount = 0;
+    for (const task of failedTasksRaw) {
+      const taskRetryCount = task.execution_stats && typeof task.execution_stats.retry_count === "number" ? task.execution_stats.retry_count : 0;
+      const taskRetryAfter = task.retry_after || 2e3;
+      const retryAfter = taskRetryAfter * Math.pow(taskRetryCount + 1, 2);
+      const executeAt = Date.now() + retryAfter;
+      const maxRetries = this.getRetryCount(task);
+      if (task._id && taskRetryCount < maxRetries) {
+        tasksToRetry.push({
+          ...task,
+          status: "scheduled",
+          execute_at: new Date(executeAt),
+          execution_stats: {
+            ...task.execution_stats || {},
+            retry_count: taskRetryCount + 1
+          }
+        });
+      } else if (task._id) {
+        finalFailedTasks.push(task);
+      } else if (taskRetryCount < maxRetries) {
+        const shouldStoreOnFailure = this.taskQueuesManager.getExecutor(task.queue_id, task.type)?.store_on_failure;
+        if (shouldStoreOnFailure) {
+          tasksToRetry.push({
+            ...task,
+            _id: this.databaseAdapter.generateId(),
+            status: "scheduled",
+            execute_at: new Date(executeAt),
+            execution_stats: {
+              ...task.execution_stats || {},
+              retry_count: taskRetryCount + 1
+            }
+          });
+        } else {
+          await this.addTasks([{
+            ...task,
+            status: "scheduled",
+            execute_at: new Date(executeAt),
+            execution_stats: {
+              ...task.execution_stats || {},
+              retry_count: taskRetryCount + 1
+            }
+          }]);
+        }
+      } else {
+        discardedTasksCount++;
+        this.logger.info(`Discarding task of type ${task.type} after ${taskRetryCount} retries`);
+      }
+    }
+    if (discardedTasksCount > 0) {
+      await this.trackDiscardedTasks(discardedTasksCount);
+    }
+    if (tasksToRetry.length > 0) {
+      await this.taskStore.updateTasksForRetry(tasksToRetry);
+    }
+    if (newTasks.length > 0) {
+      await this.addTasks(newTasks);
+    }
+    if (finalFailedTasks.length > 0) {
+      const taskIds = finalFailedTasks.map((task) => task._id);
+      await this.taskStore.markTasksAsFailed(taskIds);
+    }
+    if (successTasks.length > 0) {
+      await this.taskStore.markTasksAsSuccess(successTasks);
+    }
+  }
+  startConsumingTasks(streamName) {
+    return this.messageQueue.consumeMessagesStream(streamName, async (id, tasks) => {
+      this.logger.debug(`Processing ${tasks.length} tasks for stream ${streamName}`);
+      const {
+        failedTasks,
+        newTasks,
+        successTasks,
+        asyncTasks,
+        ignoredTasks
+      } = await this.taskRunner.run(id, tasks, this.asyncTaskManager).catch((err) => {
+        this.logger.error("Failed to execute tasks?", err);
+        return { failedTasks: [], newTasks: [], successTasks: [], asyncTasks: [], ignoredTasks: [] };
+      });
+      if (asyncTasks.length > 0 && !this.asyncTaskManager) {
+        throw new Error("Async tasks detected but AsyncTaskManager not initialized!");
+      }
+      if (asyncTasks.length > 0) {
+        this.logger.info(`Handling ${asyncTasks.length} async tasks for stream ${streamName}`);
+        for (const asyncTask of asyncTasks) {
+          const accepted = this.asyncTaskManager.handoffTask(asyncTask.task, asyncTask.promise);
+          if (!accepted) {
+            this.logger.warn(`Async queue full, requeueing task ${asyncTask.task._id} with 30s delay`);
+            await this.addTasks([{
+              ...asyncTask.task,
+              execute_at: new Date(Date.now() + 3e4)
+            }]);
+          }
+        }
+      }
+      if (ignoredTasks.length > 0) {
+        this.logger.warn(`Storing ${ignoredTasks.length} ignored tasks with no executor for stream ${streamName}`);
+        await this.taskStore.markTasksAsIgnored(ignoredTasks).catch((err) => {
+          this.logger.error("Failed to mark tasks as ignored", err);
+        });
+      }
+      await this.postProcessTasks({ failedTasks, newTasks, successTasks }).catch((err) => {
+        this.logger.error("Failed to postProcessTasks", err);
+      });
+      if (!this.queueStats.has(streamName)) {
+        this.queueStats.set(streamName, {
+          success: 0,
+          failed: 0,
+          async: 0,
+          ignored: 0
+        });
+      }
+      const stats = this.queueStats.get(streamName);
+      stats.success += successTasks.length;
+      stats.failed += failedTasks.length;
+      stats.async += asyncTasks.length;
+      stats.ignored += ignoredTasks.length;
+      await this.reportQueueStats(streamName);
+      this.logger.debug(`Completed processing for stream ${streamName}: ${successTasks.length} succeeded, ${failedTasks.length} failed, ${newTasks.length} new tasks, ${ignoredTasks.length} ignored`);
+      return { failedTasks, newTasks, successTasks, asyncTasks, ignoredTasks };
+    });
+  }
+  processMatureTasks() {
+    if (this.matureTaskTimer) clearInterval(this.matureTaskTimer);
+    this.matureTaskTimer = setInterval(async () => {
+      const lockManager = new LockManager(this.cacheAdapter, { prefix: "mature_task_lock_:" });
+      if (await lockManager.isLocked("task_processor")) {
+        this.logger.info("Mature task runner locked");
+        return;
+      }
+      try {
+        const acquired = await lockManager.acquire("task_processor", 20);
+        if (!acquired) {
+          this.logger.info("Could not acquire lock for mature task processing");
+          return;
+        }
+        const matureTasks = await this.taskStore.getMatureTasks(Date.now());
+        this.logger.debug(`Found ${matureTasks.length} mature tasks to process`);
+        await this.addTasks(matureTasks);
+      } catch (error) {
+        this.logger.error(`Error processing tasks: ${error}`);
+      } finally {
+        await lockManager.release("task_processor");
+      }
+    }, 5e3);
+  }
+  taskProcessServer() {
+    const queues = getEnabledQueues();
+    for (let i = 0; i < queues.length; i++) {
+      this.logger.info(`Starting consumer for queue: ${queues[i]}`);
+      this.startConsumingTasks(queues[i]);
+    }
+    this.logger.info("Starting mature tasks processor");
+    this.processMatureTasks();
+  }
+  processBatch(queueId, processor, limit) {
+    return this.messageQueue.consumeMessagesBatch(queueId, processor, limit);
+  }
+  async trackDiscardedTasks(count) {
+    try {
+      const now = moment.utc();
+      const hourKey = `${DISCARDED_TASKS_KEY}:${now.format("YYYY-MM-DD-HH")}`;
+      if (!this.cacheAdapter) throw new Error("Cache adapter not initialized");
+      const currentHourCountStr = await this.cacheAdapter.get(hourKey) || "0";
+      const currentHourCount = parseInt(currentHourCountStr, 10);
+      const newCount = currentHourCount + count;
+      await this.cacheAdapter.set(hourKey, newCount.toString(), 25 * 3600);
+      let total = 0;
+      try {
+        if (Math.random() < 0.1) {
+          for (let i = 0; i < 24; i++) {
+            const hourOffset = moment.utc().subtract(i, "hours");
+            const pastHourKey = `${DISCARDED_TASKS_KEY}:${hourOffset.format("YYYY-MM-DD-HH")}`;
+            const pastHourCountStr = await this.cacheAdapter.get(pastHourKey) || "0";
+            total += parseInt(pastHourCountStr, 10);
+          }
+          this.logger.info(`Added ${count} discarded tasks to metrics. Last 24h total: ${total}`);
+        } else {
+          this.logger.info(`Added ${count} discarded tasks to current hour metrics.`);
+        }
+      } catch (error) {
+        this.logger.info(`Added ${count} discarded tasks to current hour metrics.`);
+      }
+    } catch (error) {
+      this.logger.error(`Failed to track discarded tasks: ${error}`);
+    }
+  }
+  getRetryCount(task) {
+    if (typeof task.retries === "number") return task.retries;
+    const executor = this.taskQueuesManager.getExecutor(task.queue_id, task.type);
+    return executor?.default_retries ?? 3;
+  }
+  async reportQueueStats(queueName, forceSend = false) {
+    const stats = this.queueStats.get(queueName);
+    if (!stats) return;
+    const total = stats.success + stats.failed + stats.async + stats.ignored;
+    if (total === 0) return;
+    if (!forceSend && total < STATS_THRESHOLD && stats.failed < FAILURE_THRESHOLD) return;
+    `[${INSTANCE_ID}] TQ Stats for ${queueName}:
+✅ Success: ${stats.success}
+❌ Failed: ${stats.failed}
+⏳ Async: ${stats.async}
+🚫 Ignored: ${stats.ignored}`;
+    try {
+      this.logger.info(`Sent stats for ${queueName}`);
+    } catch (err) {
+      this.logger.error(`Failed to send stats: ${err}`);
+    }
+    if (!forceSend) {
+      stats.success = 0;
+      stats.failed = 0;
+      stats.async = 0;
+      stats.ignored = 0;
+    }
+  }
+  async sendFinalStats() {
+    for (const queueName of this.queueStats.keys()) {
+      await this.reportQueueStats(queueName, true);
+    }
+    if (this.queueStats.size === 0) {
+      try {
+        const message = `[${INSTANCE_ID}] TQ Final Stats:
+No tasks processed during this session`;
+        await slack.sendSlackMessage(void 0, message);
+        this.logger.info("Sent final TQ stats to Slack (no tasks)");
+      } catch (err) {
+        this.logger.error(`Failed to send final stats: ${err}`);
+      }
+    }
+  }
+}
+class TaskQueuesManager {
+  constructor(messageQueue) {
+    this.messageQueue = messageQueue;
+    this.queueTaskExecutorMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Registers a task executor with a message queue and queue name
+   * @param queueName The name of the queue
+   * @param taskType The type of task
+   * @param executor The executor for the task
+   */
+  register(queueName, taskType, executor) {
+    queueName = mq.getEnvironmentQueueName(queueName);
+    this.messageQueue.register(queueName);
+    if (!this.queueTaskExecutorMap.has(queueName)) {
+      this.queueTaskExecutorMap.set(queueName, /* @__PURE__ */ new Map());
+    }
+    const queueMap = this.queueTaskExecutorMap.get(queueName);
+    queueMap.set(taskType, executor);
+    console.log(`Registered task executor for ${taskType} on queue ${queueName}`);
+  }
+  /**
+   * Gets the task executor for a specific queue and task type
+   * @param queueName The name of the queue
+   * @param taskType The type of task
+   * @returns The executor for the task
+   */
+  getExecutor(queueName, taskType) {
+    queueName = mq.getEnvironmentQueueName(queueName);
+    const queueMap = this.queueTaskExecutorMap.get(queueName);
+    if (!queueMap) {
+      return void 0;
+    }
+    return queueMap.get(taskType);
+  }
+  /**
+   * Gets all registered queues
+   * @returns Array of queue names
+   */
+  getQueues() {
+    return Array.from(this.queueTaskExecutorMap.keys());
+  }
+  /**
+   * Gets all task types for a specific queue
+   * @param queueName The name of the queue
+   * @returns Array of task types
+   */
+  getTasksForQueue(queueName) {
+    queueName = mq.getEnvironmentQueueName(queueName);
+    const queueMap = this.queueTaskExecutorMap.get(queueName);
+    if (!queueMap) {
+      return [];
+    }
+    return Array.from(queueMap.keys());
+  }
+}
+const logger = new Logger("AsyncTaskManager", LogLevel.INFO);
+class AsyncTaskManager {
+  constructor(maxTasks = 100) {
+    this.asyncTasks = /* @__PURE__ */ new Map();
+    this.handedOffTaskIds = /* @__PURE__ */ new Set();
+    this.totalHandedOff = 0;
+    this.maxTasks = maxTasks;
+    logger.info(`AsyncTaskManager initialized with max ${maxTasks} concurrent tasks`);
+  }
+  handoffTask(task, runningPromise) {
+    if (!task._id) {
+      logger.error(`Cannot hand off task without _id (type: ${task.type})`);
+      return false;
+    }
+    const taskId = task._id.toString();
+    if (this.asyncTasks.size >= this.maxTasks) {
+      logger.warn(`Async queue full (${this.asyncTasks.size}/${this.maxTasks}), rejecting task ${taskId}`);
+      return false;
+    }
+    const entry = {
+      task,
+      promise: runningPromise,
+      startTime: Date.now()
+    };
+    this.asyncTasks.set(taskId, entry);
+    this.handedOffTaskIds.add(taskId);
+    this.totalHandedOff++;
+    logger.info(`Task ${taskId} (${task.type}) handed off to async processing (queue: ${this.asyncTasks.size}/${this.maxTasks})`);
+    runningPromise.then(() => {
+      const duration = Date.now() - entry.startTime;
+      logger.info(`Async task ${taskId} completed after ${duration}ms`);
+    }).catch((error) => {
+      const duration = Date.now() - entry.startTime;
+      logger.error(`Async task ${taskId} errored after ${duration}ms:`, error);
+    }).finally(() => {
+      this.asyncTasks.delete(taskId);
+      this.handedOffTaskIds.delete(taskId);
+      logger.debug(`Task ${taskId} removed from async queue (remaining: ${this.asyncTasks.size})`);
+    });
+    return true;
+  }
+  async shutdown() {
+    logger.info(`Shutting down AsyncTaskManager with ${this.asyncTasks.size} tasks still running`);
+    const gracePeriod = 1e4;
+    logger.info(`Waiting ${gracePeriod}ms for tasks to complete...`);
+    await new Promise((resolve) => setTimeout(resolve, gracePeriod));
+    if (this.asyncTasks.size > 0) {
+      logger.warn(`${this.asyncTasks.size} tasks still running after grace period, they will continue in background`);
+      for (const [taskId, entry] of this.asyncTasks) {
+        const runtime = Date.now() - entry.startTime;
+        logger.info(`Task ${taskId} (${entry.task.type}) has been running for ${runtime}ms`);
+      }
+    }
+    logger.info("AsyncTaskManager shutdown complete");
+  }
+  getMetrics() {
+    return {
+      activeTaskCount: this.asyncTasks.size,
+      totalHandedOff: this.totalHandedOff,
+      maxTasks: this.maxTasks,
+      utilizationPercent: this.asyncTasks.size / this.maxTasks * 100
+    };
+  }
+  isHandedOff(taskId) {
+    return this.handedOffTaskIds.has(taskId);
+  }
+  canAcceptTask() {
+    return this.asyncTasks.size < this.maxTasks;
+  }
+}
+exports.Actions = Actions;
+exports.AsyncActions = AsyncActions;
+exports.AsyncTaskManager = AsyncTaskManager;
+exports.InMemoryAdapter = InMemoryAdapter;
+exports.MongoDbAdapter = MongoDbAdapter;
+exports.TaskHandler = TaskHandler;
+exports.TaskQueuesManager = TaskQueuesManager;
+exports.TaskRunner = TaskRunner;
+exports.TaskStore = TaskStore;
+exports.getEnabledQueues = getEnabledQueues;
+exports.setKeyGenerator = setKeyGenerator;
+//# sourceMappingURL=index.js.map